新手初学Java集合框架

新手初学Java集合框架

目录java集合框架集合List接口ArrayListVectorLinkedList：泛型：Set接口HashSetTreeSetMap接口特点：遍历：HashMapHashtableTreeMap总结

Java集合框架

集合

概念：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。

集合和数组的区别：

数组长度固定，集合长度不固定

数组可以存储基本类型和引用类型，集合只能存储引用类型。

测试

/*

1.添加 2.删除 3.遍历 4.判断

*/

Collection col = new ArrayList();

col.add("张三");

col.add("李四");

col.add("王五");

// col.add("张三");

System.out.println(col);

// col.remove("张三");

// System.out.println(col);

for (Object o : col) {

System.out.println(o);

}

System.out.println("------------------");

Iterator it = col.iterator();

while (it.hasNext()){

String next = (String) it.next();

System.out.println(next);

}

System.out.println(col.isEmpty());

System.out.println(col.contains("张三"));

List接口

特点：有序、有下标、元素可以重复。

可以通过角标在指定位置添加查询元素。

List list = new ArrayList();

list.add("java");

list.add("c++");

list.add(1,"python");

list.add(".net");

System.out.println(list.size());

System.out.println(list.toString());

//1.for each遍历

System.out.println("---------------");

for (Object o : list) {

System.out.println(o);

}

//2.迭代器遍历

System.out.println("---------------");

Iterator iterator = list.iterator();

while (iterator.hasNext()){

System.out.println(iterator.next());

}

//3.list迭代器遍历

System.out.println("--------正序-------");

ListIterator listIterator = list.listIterator();

while (listIterator.hasNext()){

System.out.println(listIterator.next());

}

//逆序前必须先进行正序遍历，让指针指向列表最后一个元素，才能开发遍历

System.out.println("--------逆序-------");

while (listIterator.hasPrevious()){

System.out.println(listIterator.previousIndex() + ":" +listIterator.previous());

}

添加数字等基本类型数据时，会进行自动装箱的操作。

删除数字元素需要通过下标来删除，或者将需要删除的数字转成object类或者该类型对应的包装类。

subList:返回一个子集合，含头不含尾。

List实现类

ArrayList

数组存储结构，查询快、增删慢；

JDK1.2版本出现，运行效率快，线程不安全。

源码分析：

DEFAULT_CAPACITY = 10 默认容量 。注意：如果没有向集合中添加任何元素时，容量为0，添加一个元素之后，容量为10。每次扩容大小都是原来的1.5倍，如添加第11个元素时，容量由10变为了15。

add（）方法源码：为什么添加一个元素之后，容量为10。

public boolean add(E e) {

ensureCapacityInternal(size + 1); // Increments modCount!!增长修改个数

elementData[size++] = e;

return true;

}

​private void ensureCapacityInternal(int minCapacity) {

if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);

}

​ ensureExplicitCapacity(minCapacity);

}

​private void ensureExplicitCapacity(int minCapacity) {

modCount++;

​

// overflow-conscious code

if (minCapacity - elementData.length > 0)

grow(minCapacity);

}

​private void grow(int minCapacity) {

// overflow-conscious code

int oldCapacity = elementData.length;

int newCapacity = oldCapacity + (oldCapacity >> 1);

if (newCapacity - minCapacity < 0)

newCapacity = minCapacity;

if (newCapacity - MAX_ARRAY_SIZE > 0)

newCapacity = hugeCapacity(minCapacity);

// minCapacity is usually close to size, so this is a win:

elementData = Arrays.copyOf(elementData, newCapacity);

}

elemetnData 存放元素的数组

size 实际元素个数

测试代码：

ArrayList arrayList = new ArrayList();

Student s1 = new Student("张三",18);

Student s2 = new Student("李四",18);

Student s3 = new Student("王五",18);

arrayList.add(s1);

arrayList.add(s2);

arrayList.add(s3);

System.out.println(arrayList.toString());

//删除元素（需要重写equals方法）

arrayList.remove(new Student("李四",18));

System.out.println(arrayList.size());

public boolean equals(Object o) {

if (this == o) return true;

if (o == null || getClass() != o.getClass()) return false;

Student student = (Student) o;

return age == student.age && Objects.equals(name, student.name);

}

Vector

数组存储结构，查询快，增删慢；

JDK1.0版本出现，运行效率慢、线程安全；

枚举器遍历

Vector vector = new Vector();

vector.add("java");

vector.add("python");

vector.add(".net");

System.out.println(vector.toString());

//枚举器遍历

Enumeration elements = vector.elements();

while (elements.hasMoreElements()){

System.out.println(elements.nextElement());

}

LinkedList：

双向链表存储结构，增删快，查询慢。

泛型：

时JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递；

常见形式由泛型类、泛型接口、泛型方法；

好处：

提高代码的重用性

防止类型转换异常，提高代码的安全性

泛型集合：参数化类型、类型安全的集合，强制集合元素的类型必须一致。

特点：

编译时即可检查，而非运行时抛出异常。

访问时，不必类型转换。

不同泛型之间引用不能相互赋值，泛型不存在多态。

Set接口

特点：无序、无下标、元素不可重复

方法：全部继承自Collection中的方法。

Set实现类

HashSet

存储结构：哈希表（数组+链表+红黑树）

基于HashCode实现元素不重复

根据hashcode计算保存的位置，如果此位置为空，则直接保存。如果不为空，执行下一步。

当存入元素的哈希码相同时，会调用equals进行确认，如果为true，则拒绝后者存入。否则，则生成链表。

public HashSet(){

map = new HashMap<>();

}

测试代码：

HashSet set = new HashSet<>();

Student s1 = new Student("张三",18);

Student s2 = new Student("李四",18);

Student s3 = new Student("王五",18);

set.add(s1);

set.add(s2);

set.add(s3);

// set.add(new Student("李四",18));

System.out.println(set.size());

System.out.println(set.toString());

// set.remove(new Student("李四",18));

// System.out.println(set.size());

// System.out.println(set.toString());

for (Student student : set) {

System.out.println(student);

}

System.out.println("====================");

Iterator iterator = set.iterator();

while (iterator.hasNext()){

System.out.println(iterator.next());

}

public boolean equals(Object o) {

if (this == o) return true;

if (o == null || getClass() != o.getClass()) return false;

Student student = (Student) o;

return age == student.age && Objects.equals(name, student.name);

}

​public int hashCode() {

return Objects.hash(name, agehttp://);

}

hashcode重写方法中加入31的原因

1.31是一个质数，减少散列冲突

2.31提高执行效率

TreeSet

存储结构：红黑树

基于排列顺序实现元素不重复

实现了SortedSet接口，对集合元素自动排序

元素对象的类型必须实现Comparable接口，指定排列规则

通过CompareTo方法确定是否为重复元素

测试代码：使用TreeSet集合实现字符串按照长度进行排序

TreeSet treeSet = new TreeSet<>(new Comparator() {

​ @Override

public int compare(String o1, String o2) {

int n1 = o1.length() - o2.length();

int n2 = o1.compareTo(o2);

return n1==0?n2:n1;

}

treeSet.add("zhangSan");

treeSet.add("wkf");

treeSet.add("asd");

treeSet.add("abc");

treeSet.add("ljCv");

treeSet.add("liSi");

treeSet.add("wanG");

​ System.outhttp://.println(treeSet.toString());

System.out.println(treeSet.size());

​

Map接口

特点：

1.用于储存任意键值对（Key，Value）

2.键：无序、无下标、不允许重复

3.值：无序、无下标、允许重复

遍历：

keySet（）方法遍历：拿到key的set集合。

entrySet（）方法遍历：将map封装成entry键值对集合。

测试代码：

Map map = new HashMap<>();

map.put("wkf","666");

map.put("qwe","678");

map.put("kfc","999");

map.put("asd","694");

Set keySet = map.keySet();

for (String s : keySet) {

System.out.println(s + "=" + map.get(s));

}

System.out.println("===================");

Set> entries = map.entrySet();

for (Map.Entry entry : entries) {

System.out.println(entry.getKey() +"=" + entry.getValue() );

}

HashMap

JDK1.2版本，线程不安全，运行效率快；允许用null作为key或是value。

构造一个具有默认初始容量16和默认加载因子0.75的空HashMap。

加载因子：比如当前集合容量为100，那么当数据存储到第75个位置是进行扩容操作。

源码分析

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // hashMap初始容量大小16

static final int MAXIMUM_CAPACITY = 1 << 30;//hashMap的数组最大容量

static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认加载因子

static final int TREEIFY_THRESHOLD = 8;//jdk1.8开始，当链表长度大于8时，调整成红黑树

static final int UNTREEIFY_THRESHOLD = 6;//jdk1.8开始，当链表长度小于6时，调整成链表

static final int MIN_TREEIFY_CAPACITY = 64;//jdk1.8开始，当链表长度大于8时，并且集合元素个数大于等于64时调整成红黑树

transient Node[] table;//哈希表中的数组

总结：

HashMap刚创建时，table是null，为了节省空间，当添加第一个元素时，table容量调整为16

当元素个数大于阈值（16*0.75=12）时，会进行扩容，扩容后大小为原来的两倍。目的是减少调整元素的个数

jdk1.8开始，当链表长度大于8时，并且集合元素个数大于等于64时调整成红黑树，目的是提高执行效率

jdk1.8开始，当链表长度小于6时，调整成链表

jdk1.8以前，链表时头插入，jdk1.8以后是尾插入

Hashtable

JDK1.0版本，线程安全，运行效率慢；不允许null作为key或是value

Properties：

Hashtable的子类，要求key和value都是String，通常用于配置文件的读取。

TreeMap

实现了SortedMap接口（是Map的子接口），可以对key自动排序。

Collections工具类

sort（）：升序排列

copy（）：复制

binarySearch（）：二分查找

Collections.binarySearch(list,需要查找的值);

reverse（）：反转

shuffle（）：打乱集合中的元素

list转成数组：

list.toArray(new Integer[0]);

数组转成集合

Arrays.asList(names);

集合是一个受限集合，不能添加 和

总结

本篇文章就到这里了，希望能给您带来帮助，也希望您能够多多关注我们的更多内容!

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。