Java集合的基础知识

集合

前言

一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象 的操作，就要对对象进行存储。

另一方面，使用Array存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。

数组在内存存储方面的特点:

• 数组初始化以后，长度就确定了。 String arr[];
• 数组声明的类型，就决定了进行元素初始化时的类型

数组在存储数据方面的弊端：

• 数组初始化以后，长度就不可变了，不便于扩展
• 数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。 同时无法直接获取存储元素的个数
• 数组存储的数据是有序的、可以重复的。---->存储数据的特点单一

综上所诉，引入java集合类的必要性

• Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。

集合类概述

java 集合可分为 Collection 和 Map 两种体系

Collection接口：单列数据，定义了存取一组对象的方法的集合

• List：元素有序、可重复的集合 -------“动态数组” |- ArrayList …LinkedList Vector
• Set：元素无序、不可重复的集合 |-HashSet … LinkedHashSet …TreeSet

Map接口：双列数据，保存具有映射关系“key-value对”的集合

• |-HashMap…Properties…LinkedHashMap…TreeMap

Collection接口

1、添加 add(Object obj) addAll(Collection coll)

2、获取有效元素的个数 int size()

3、清空集合 void clear()

4、是否是空集合 boolean isEmpty()

5、是否包含某个元素 boolean contains(Object obj)：是通过元素的equals方法来判断是否 是同一个对象 boolean containsAll(Collection c)：也是调用元素的equals方法来比 较的。拿两个集合的元素挨个比较。

6、删除 boolean remove(Object obj) ：通过元素的equals方法判断是否是 要删除的那个元素。只会删除找到的第一个元素 boolean removeAll(Collection coll)：取当前集合的差集

7、取两个集合的交集 boolean retainAll(Collection c)：把交集的结果存在当前集合中，不影响c

8、集合是否相等 boolean equals(Object obj)

9、转成对象数组 Object[] toArray() 数组->集合 Arrays.asList()

10、获取集合对象的哈希值 hashCode()

11、遍历  iterator()：返回迭代器对象，用于集合遍历、

添加类时，重写类的equals方法

Collection coll=new ArrayList();

//add(Obeject e) :将元素添加到集合roll
//添加类时，重写类的equals方法
coll.add(new Persion(22,"YQQ"));
coll.add("aa");
coll.add("bb");
coll.add(123);
coll.add(new Date());
coll.add(new String("Tom"));


//size()：获取元素长度
System.out.println(coll.size());


//addAll() 将集合coll_1中的元素添加到coll
Collection coll_1=new ArrayList();

coll.addAll(coll_1);
System.out.println(coll);


//contains(Object e):查看是否包含 e
//调用时 会调用obj对象的equals方法
System.out.println("Tom");
System.out.println(coll.contains(new String("Tom")));
System.out.println("YYQ");
//调用Persion中的equals方法来比较coll里面有没有
System.out.println(coll.contains(new Persion(22, "YQQ")));

//containsAll(Collectin coll)判断形参coll1中的所有元素是否都存在于当前集合中
Collection coll_2 = Arrays.asList(123,456);
System.out.println("containsAll:"+coll.containsAll(coll_2));

//remove(Object obj：移除数据
// 仍要重写equals方法 同样调用该对象的equals()方法
System.out.println("remove:"+coll.remove(new Persion(22, "YQQ")));

//removeAll(Collection coll) :移除coll中的所有元素(交集)，去除共有元素
coll.removeAll(coll_2);
System.out.println("removeAll"+coll);

//retainAll(Collection coll)获取当前集合和coll的交集，结果返回为当前集合
coll.retainAll(coll_2);

//equals(Object obj):要想返回ture 当前对象和形参对象集合的元素都想同
// ArrayList有序的 顺序不一样也是false
coll.equals(coll_1);

//hashcode():返回当前对象的hash值
System.out.println(coll.hashCode());

//集合->数组 toArray()
Object[] objects = coll.toArray();
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
//扩展 数组到集合 Arrays.asList Arrays类的静态方法
List<String> list = Arrays.asList(new String[]{"AAA", "BBB", "CCC"});
System.out.println(list);

//iterator():返回iterator接口的实例，用于遍历集合元素



//clear()：清空集合
coll.clear();

//isEmpty():查看集合是否为空
System.out.println(coll.isEmpty());

迭代器iterator

Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。

GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元 素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。

Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了 Iterator接口的对象。

Iterator 仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象，则必须有一个被迭代的集合。 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合 的第一个元素之前。

//迭代器接口 iterator ->遍历集合
//此处是利用多态 查看collection的方法，左边编译，右边运行
Collection coll=new ArrayList();

//add(Obeject e) :将元素添加到集合roll
//添加类时，重写类的equals方法
coll.add(new Persion(22,"YQQ"));
coll.add("aa");
coll.add("bb");
coll.add(123);
coll.add(new Date());
coll.add(new String("Tom"));

Iterator iterator= coll.iterator();
// //方式一
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// //方式二
// for (int i = 0; i < coll.size(); i++) {
// System.out.println(iterator.next());
// }

//方式三 在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且
//下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常。
while (iterator.hasNext()){
System.out.println(iterator.next());
}


}

//删除集合中Tom对象 
Iterator iterator = coll.iterator();
while(iterator.hasNext()){
        Object obj=iterator.next();
        if(obj.equals("Tom")) //指针指向这个数据
            iterator.remove();
            }
Iterator iterator_1 = coll.iterator();
while(iterator_1.hasNext()){
        System.out.println("第二次"+iterator_1.next());
}

增强for循环

!

Collection子接口： List接口

鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组

List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。

List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据 序号存取容器中的元素。

JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

• 同: 三个接口都是实现了List接口，储存数据的特点相同：存储有序，可重复的数据
• 不同: Vector 古老的接口 List

ArrayList 源码分析

LinkList源码分析

体现了双向链表

Vector源码分析

//void add(int index, Object ele):在index位置插入ele元素
list.add(1,"1111");


//boolean addAll(int index, Collection eles):从index位置开始将eles中
// 的所有元素添加进来
List list_1= Arrays.asList(222,222);
list.addAll(1,list_1);


// Object get(int index):获取指定index位置的元素
System.out.println(list.get(0));

// int indexOf(Object obj):返回obj在集合中首次出现的位置 没有返回-1
System.out.println("123第一次出现"+list.indexOf(123));

// int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
System.out.println("123最后一次出现"+list.lastIndexOf(123));

// Object remove(int index):移除指定index位置的元素，并返回此元素
Object remove = list.remove(0);
System.out.println(remove.toString()+list);

// Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(0,11111);

// List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex
// 位置的子集合 前闭后开
List list1 = list.subList(0, 1);
System.out.println(list1);

总结常用方法

Collection子接口： Set接口

无序不重复

实现类:HashSet

hashset 底层是数组加链表

HashSet是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。

HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除 性能。

HashSet 具有以下特点：

• 不能保证元素的排列顺序
• HashSet 不是线程安全的
• 集合元素可以是 null

HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相 等，并且两个对象的 equals() 方法返回值也相等。

对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”

实现类:TreeSet

可以按照添加对象的指定属性进行排序(同一个类)

1 自然排序-Comparable

其中比较两个对象是否相同的标准为:compareTo()返回0，不在是equals()方法

//TreeSet 同一个类的对象
TreeSet treeSet=new TreeSet();
treeSet.add(new Persion(23,"YYQ"));
treeSet.add(new Persion(21,"Lr"));
treeSet.add(new Persion(24,"HLZ"));
treeSet.add(new Persion(222,"YYYYYYYQ"));
treeSet.add(new Persion(222,"YYYQ"));

Iterator iterator = treeSet.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}

对Persion实现comparable接口，重写compareTo()接口

@Override
public int compareTo(Object o) {
if (o instanceof Persion){
    Persion p=(Persion)o;
    int i = this.name.compareTo(p.name);
    if(i!=0)
        return i;
    else
        return -Integer.compare(this.age,p.age);

}
throw new RuntimeException("数据类型错误");
}

2 定制排序 comparator-

Comparator com =new Comparator() {
@Override
public int compare(Object o1, Object o2) {
        if(o1 instanceof Persion && o2 instanceof Persion){
                Persion p1=(Persion)o1;
                Persion p2=(Persion)o2;
            return Integer.compare(p1.age,p2.age);
            }
        throw new RuntimeException("类型错误");
        }
};
//TreeSet 同一个类的对象
TreeSet treeSet=new TreeSet(com);
treeSet.add(new Persion(23,"YYQ"));
treeSet.add(new Persion(21,"Lr"));
treeSet.add(new Persion(24,"HLZ"));
treeSet.add(new Persion(222,"YYYYYYYQ"));
treeSet.add(new Persion(222,"YYYQ"));

Iterator iterator = treeSet.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}

Map接口

双列数据 key -value

 Map与Collection并列存在。用于保存具有映射关系的数据:key-value

 Map 中的 key 和 value 都可以是任何引用类型的数据

 Map 中的 key 用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法

 常用String类作为Map的“键”

 key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value

 Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和 Properties。其中，HashMap是 Map 接口使用频率最高的实现类

/**
* /----Map:储存双列数据，储存key-value对的数据
*          /----HashMap:作为Map的主要实现类，线程不安全，效率高；储存null的key和value
*              /----linkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历
*                   原因:在原有的HashMap底层结构基础上，添加了一对双向指针
*                   对于频繁的遍历操作，效率高
*          /----TreeMap:保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序和定制排序
*                   底层使用红黑树
*          /----HashTable:作为古老的实现类，线程安全，效率低；不能储存null的key和value
*                    /----Properties:常用来配置文件。key和value都是String类型。

* HashMap的底层:数组+链表（JDK7之前）
* 数组＋链表＋红黑树（JDK8）

* 二、Map结构的理解
*      Map中的key无序的，不可重复的，使用Set存储所有的key ---->key所在的类要重写equals()和hashcCode()方法
*      Map中的value无序的，可重复的，使用Collection储存所有的value ---->value所在的类重写equals()方法
*      一个Key-value键值对构成了一个Entry对象。
*      Map中的entry：无序的、不可重复的，使用Set存储所有的entry
*
*
* 三、HashMap的底层实现原理
*      Jdk7:
*      HashMap map =new HashMap();
*      在实例化之后，底层创建了长度是16的一维数组 Entry[] table
*      ...可能执行很多put
*      map.(key1,values1)
*      首先，调用key1所在类的hashCode()方法计算key1的 哈希值，此哈希值经过某种算法计算之后，得到在Entry数组中的存放位置，
*          如果此位置上数据为空，此时的key1-value1添加成功
*          如果此位置上数据不为空，(意味着此位置存在一个或者多个数据(以链表的形式存在)),比较key1和已经存在的多个数据的hash值
*              如果key1的哈希值和已经存在的数据的哈希值都不同，此时key1-value1添加成功。
*              如果key1的哈希值和已经存在的数据(key2-value2)的哈希值相同，继续比较，调用key1所在类的equals(key2)
*                  如果equals()返回false，则key1-value1添加成功
*                  如果equals()返回为ture，则value1替换value2
*
*      在添加过程中，会涉及到扩容问题，当超出临界值且 默认的扩容是原来的二倍，并将原来的数据复制过来
*

*      Jdk8相较于jDk7的区别
*          1、new HashCode() ：底层没有创建一个长度为16的数组
*          2、jdk8 底层数组为:Node[] 而非Entry[]
*          3、首次调用put(key，value)方法时，底层创建长度为16的数组
*          4、jdk7底层结构只有数组+链表
*      jdk8底层结构 数组＋链表+红黑树
* 当数组的某一个索引位置上的元素以链表形式存在的数据个数>8 且当前数组的长度＞64时，
* 此时此索引位置上的所有数据改为红黑树储存

HashMap的存储结构
JDK 7及以前版本：HashMap是数组+链表结构(即为链地址法)。 JDK 8版本发布以后：HashMap是数组+链表+红黑树实现。

11.6 Map接口：常用方法
// 添加、删除、修改操作：
// Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
// void putAll(Map m):将m中的所有key-value对存放到当前map中
// Object remove(Object key)：移除指定key的key-value对，并返回value
// void clear()：清空当前map中的所有数据
// 元素查询的操作：
// Object get(Object key)：获取指定key对应的value
// boolean containsKey(Object key)：是否包含指定的key
// boolean containsValue(Object value)：是否包含指定的value
// int size()：返回map中key-value对的个数
// boolean isEmpty()：判断当前map是否为空
// boolean equals(Object obj)：判断当前map和参数对象obj是否相等


// 元视图操作的方法：
// Set keySet()：返回所有key构成的Set集合
// Collection values()：返回所有value构成的Collection集合
// Set entrySet()：返回所有key-value对构成的Set集合

//遍历所有的key
Set set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext())
System.out.println(iterator.next());

//遍历所有的value
Collection values = map.values();
for(Object e : values)
System.out.println(e);

//方式一:遍历所有的key-value
Set set1 = map.entrySet();
Iterator iterator1 = set1.iterator();
while (iterator1.hasNext()){
Object obj=iterator1.next();
Map.Entry entry=(Map.Entry)obj;
//entrySet集合中的元素都是entry
System.out.println("key:"+entry.getKey()+"--->value："+entry.getValue());
}

//方式二 遍历所有的key-value
Iterator iterator2 = set.iterator();
while (iterator2.hasNext()){
Object key = iterator2.next();
Object val = map.get(key);
System.out.println("key:--"+key+"---:"+val);

TreeMap

/向TreeMap中添加Key-value 要求key必须是同一个类
//因为要按照key进行自然排序和定制排序

//自然排序 Persion实现comparable接口的compareTo接口 
TreeMap map=new TreeMap();
Persion p1=new Persion(22,"YYq");
Persion p2=new Persion(23,"Y2Yq");
Persion p3=new Persion(24,"Y21Yq");

map.put(p1,10);
map.put(p2,122);
map.put(p3,1122);
Set set = map.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()){
Object key = iterator.next();
Object value = map.get(key);
System.out.println(key+"----------"+value);
}

@Test
public void test1(){

//定制排序
TreeMap map=new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Persion && o2 instanceof Persion){
Persion p1=(Persion)o1;
Persion p2=(Persion)o2;
int compare = Integer.compare(p1.age, p2.age);
if(compare!=0) return compare;
else return p1.name.compareTo(p2.name);
}
throw new RuntimeException("类型不匹配");
}
});
Persion p1=new Persion(22,"YYq");
Persion p2=new Persion(22,"Y2Yq");
Persion p3=new Persion(24,"Y21Yq");

map.put(p1,10);
map.put(p2,122);
map.put(p3,1122);
Set set = map.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()){
Object key = iterator.next();
Object value = map.get(key);
System.out.println(key+"----------"+value);
}
}

Properties

Map->Hashable->Properties-------------------------------------------

• Properties 类是 Hashtable 的子类，该对象用于处理属性文件
• 由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key 和 value 都是字符串类型
• 存取数据时，建议使用setProperty(String key,String value)方法和 getProperty(String key)方法

Properties pro =new Properties();
FileInputStream fis =new FileInputStream("jdbc.properties");
pro.load(fis);
String name = pro.getProperty("name");
String password = pro.getProperty("password");
System.out.println(name+"----"+password);
fis.close();

Collections工具类

Collections 是一个操作 Set、List 和 Map 等集合的工具类

// 排序操作：（均为static方法）
//reverse(List)：反转 List 中元素的顺序
//shuffle(List)：对 List 集合元素进行随机排序
//sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
//sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
//swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换


// 查找、替换
//Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
//Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
//Object min(Collection)
//Object min(Collection，Comparator)
//int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
//void copy(List dest,List src)：将src中的内容复制到dest中
//boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值


//使用Collections.copy() 注意dest必须被撑开
List list=new ArrayList();
List list1 = Collections.synchronizedList(list);
list.add(123);
list.add(12);
list.add(-13);
list.add(2141);
List dest= Arrays.asList(new Object[list.size()]);
//把list->放入dest
Collections.copy(dest,list);
System.out.println(dest);