java集合框架

java集合框架

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

• 数组长度固定，集合长度不固定
  
• 数组可以存储基本数据类型和引用数据类型，集合只能存储引用数据类型（存储基本数据类型自动装箱）
  

Collection类

所有集合类的父接口
集合体系结构：包括List接口和Set接口的区别

Collection特点：代表一组任意类型的对象，无序、无下标
各元素对象之间没有指定的顺序，允许有重复元素和多个Null元素对象。所以不可以排序，也不可以找出第几个第几个元素。
方法：

1.         Collection collection = new ArrayList();
2.         //添加
3.         collection.add("苹果");
4.         collection.add("西瓜");
5.         collection.add("葡萄");
6.         System.out.println(collection.size());
7.         System.out.println(collection);//相当于调用toString
8. //        删除
9.         collection.remove("苹果");
10.         System.out.println(collection);
11. //        清除
12. //        collection.clear();
14. //        遍历
15. //        方法一,因为collection无下标所以不要用for-i
16.         for (Object o : collection) {
18.         }
19. //        方法二：迭代器(专门遍历集合的一种方式),Iterator是一个接口
20.         Iterator it = collection.iterator();
21.         //是否有下一个元素
22.         it.next();
23.         it.remove();//迭代器中只能用这种方法删除,不能用本来的删除,删除的是栈存储的地址，通过equals方法
24.         while (it.hasNext()){
25.             //等于下一个元素
26.             String s =(String) it.next();
27.             System.out.println(s);
28.         }
31. //        判断
32.         System.out.println(collection.contains("葡萄"));
33.                 System.out.println(collection.isEmpty());
35. /*
36. 3
37. [苹果, 西瓜, 葡萄]
38. [西瓜, 葡萄]
39. 葡萄
40. true
41. false

复制代码

List类

特点：有序、有下标、元素可以重复
在拥有父类的方法之外，List特有方法

另外List也有特殊的迭代器列表迭代器ListIterator可以向前或者向后遍历：

1. List list = new ArrayList();
2. //       添加
3.         list.add(0,"苹果");
4.         list.add("西瓜");
5. // 列表迭代器
6.         ListIterator listIterator = list.listIterator();
7.         while (listIterator.hasNext()){
8.             System.out.println(listIterator.nextIndex()+":"+listIterator.next());
9.         }
10.         System.out.println("------从后往前---------------");
11.         while (listIterator.hasPrevious()){
12.             System.out.println(listIterator.nextIndex()+":"+listIterator.previous());
13.         }
15.         //查询位置
16.         System.out.println(list.indexOf("苹果"));
18. /*
19. 0:苹果
20. 1:西瓜
21. ------从后往前---------------
22. 2:西瓜
23. 1:苹果
24. 0

复制代码

list删除数字：

1. List list = new ArrayList();
2. list.add(1);
3. list.add(2);
4. //直接输入数字会被认为是下标，又因为集合的基本数据类型经过了装箱，所以这样写
5. list.remove((Object)1);或者new Integer（1）也可以
6. System.out.println(list);
7. //[2]

复制代码

其他方法不再演示
List的实现类：ArrayList,Vector,LinkedList
ArrayList类

• 以数组结构实现，查询快、增删慢
  
• 运行效率快、线程不安全
  
• List的实现类
  

1. ArrayList arrayList = new ArrayList();

复制代码

一些源码分析：

• 默认容量：DEFAULT_CAPACITY = 10，没添加如何元素0,大于10就是元素个数;
  
• 存放元素的数组：elementData
  
• 实际元素个数：size
  

Vector类

• 数组结构实现，查询快、增删慢
  
• 运行效率慢、线程安全
  
• 用的少
  
• List的实现类
  

创建方法同上，方法自己看文档
LinkedList类

• 链表结构（双向链表）实现，增删快、查询慢。
  

增删改查方法类似上面，不在赘述
至于链表结构学了c或者数据结构应该都懂吧
泛型

本质上是参数化类型，把类型当做参数传递
常见形式有泛型类、泛型接口和泛型方法
语法：
，T是类型占位符，表示一种引用类型,可以写多个
作用：
提高代码重用性
防止类型转换异常，提高安全性
泛型类

1. public class MyGeneric <T>{
2.     T t;
3.     public  void show(T t){
4. //        T t1 = new T();  这是不合法，不能new因为不确定类型
5.         System.out.println(t);
6.     }
8.     public T getT(){
9.         return  t;
10.     }
12.     public static void main(String[] args) {
13.         //泛型类中必须是引用数据类型，基本数据类型就用包装类。右边的String可写可不写
14.         MyGeneric<String> myGeneric = new MyGeneric<String>();
15.         myGeneric.t="hello";
16.         System.out.println(myGeneric.t);
17.         myGeneric.show("大家好");
18.         
19.     }
20. }
21. /*
22. hello
23. 大家好

复制代码

泛型接口

泛型接口基本和泛型类类似，只不过其他类实现它时传入引用类型但是当实现泛型接口时也不确定如下，后面声明类的时候再传

1. public class  Student  implements MyGeneric<String>{}
2. public class  Student<T>  implements MyGeneric<T>{}

复制代码

泛型方法

1. public class MyGeneric {
2.     //先声明泛型方法，之后可以返回类型或者在参数使用泛型
3.     public <T>  T show(T t){
4.         return t;
5.     }
7.     public static void main(String[] args) {
8.         MyGeneric myGeneric = new MyGeneric();
9. //        泛型类型由传入的数据类型决定
10.         myGeneric.show("大家好");
11.         myGeneric.show(1);
13.     }
14. }

复制代码

泛型好处

• 提高重用性
  
• 防止类型转换异常
  

泛型集合

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

1. ArrayList<String> list = new ArrayList<String>();
2. //不写泛型默认是Object

复制代码

当不使用泛型时

1. ArrayList list = new ArrayList();
2. list.add("aa");
3. list.add(1);
4. for (Object o : list) {
5.     String s= (String) o;
6. }
7. /*
8. Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')

复制代码

Set类

特点：无序、无下标、元素不可重复
各元素对象之间没有指定的顺序，不允许有重复元素，最多允许有一个Null元素对象
一个不包含重复元素的Collection，方法和Collection完全一样
继承Collection，是接口

1.         Set<String> set = new HashSet<>();
2. //        增删改查同Collection

复制代码

Set的实现类：HashSet，TreeSet
HashSet类

• 基于HashCode计算元素的存放位置
  
• 存储结构：哈希表（数组+链表+红黑树）
  
• 当存入的一个元素时如果对应哈希码数组位置为空直接存入，如果已有元素会调用equals进行确认，如果为true，则拒绝存入；为false，存储在数组同一个位置与已有元素形成链表（返回哈希值，有方法hashCode）(另外删除等其他方法时同理也是通过hashCode和equals方法)
  

1. HashSet<String> hashSet = new HashSet<>();

复制代码

TreeSet类

• 基于排序顺序实现元素不重复
  
• 实现了SortedSet接口，对集合元素自动排序
  
• 元素对象的类型必须实现Comparable接口，指定排序规则
  
• 通过Comparable的一个compareTo方法确定是否为重复元素
  
• 存储结构：红黑树结构（二叉查找树的一种）
  

1. TreeSet<String> treeSet = new TreeSet<>();
2. treeSet.add("b");
3. treeSet.add("a");
4. treeSet.add("c");
5. treeSet.add("c");
6. System.out.println(treeSet);
7. //根据字典序排序，重复的不添加
8. //out:[a, b, c]

复制代码

删除等操作类似
要求：TreeSet如果要装入对象，对象必须实现Comparable(泛型接口)重写compareTo方法

1. public class  Student  implements  Comparable<Student>{
2.     String name="11";
3.     int age=11;
4.     //先按姓名再按照年龄比,相同返回0
5.     @Override
6.     public int compareTo(Student o) {
7.         //String的compareTo：相同返回0
8.         int n1 = this.name.compareTo(o.name);
9.         int n2 = this.age-o.age;
10.         //如果name相同n2否则返回n1
11.         return  n1==0 ? n2:n1;
12.     }
13.    
14.     public static void main(String[] args) {
15.         TreeSet<Student> treeSet = new TreeSet<>();
16.         Student s1 = new Student();
17.         treeSet.add(s1);
18.     }
19. }
20. //删除等其他操作同理

复制代码

Comparator和Comparable

上文提到如果TreeSet要装入自定义的类的话需要实现Comparable类，事实上也可以通过实现Comparator装入

• Comparable：可比较的
  
• Comparator：实现定制比较（比较器）
  

1. TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
2.     @Override
3.     public int compare(Student o1, Student o2) {
4.         //比较方法:自己根据项目要求写,相同返回0，上面Comparable的compareTo也是同理
5.         return 0;
6.     }
7. });
8. Student s1 = new Student();
9. treeSet.add(s1);

复制代码

Map集合


特点：

• 用来存储键值对
  
• 键：无序、无下标、不允许重复
  
• 值：无序、无下标、运行重复
  
• 是接口
  

常用方法：

1. Map<String,String> map = new HashMap<>();
2. map.put("CHA","中国");
3. map.put("USA","美国");
4. map.put("UK","英国");
5. //替换掉键值对上一个值
6. map.put("UK","联合王国");
8. System.out.println(map.size());
9. System.out.println(map.toString());
10. //删除
11. map.remove("UK");
12. System.out.println(map.toString());
13. //使用KeySet（）遍历：得到一个存储了键的Set
14. System.out.println("keySet遍历-----------------");
15. Set<String> keySet = map.keySet();
16. for (String s : keySet) {
17.     //get通过键得到值
18.     System.out.println(s+":"+map.get(s));
19. }
20. //使用entrySet方法遍历：得到一个存储键值对的Map.Entry:效率更高
21. System.out.println("entrySet方法遍历-------------");
22. Set<Map.Entry<String, String>> entries = map.entrySet();
23. for (Map.Entry<String, String> entry : entries) {
24.     System.out.println(entry.getKey()+":"+entry.getValue());
25. }
26. //判断
27. System.out.println(map.containsKey("USA"));
28. System.out.println(map.containsValue("英国"));
30. /*
31. 3
32. {USA=美国, UK=联合王国, CHA=中国}
33. {USA=美国, CHA=中国}
34. keySet遍历-----------------
35. USA:美国
36. CHA:中国
37. entrySet方法遍历-------------
38. USA:美国
39. CHA:中国
40. true
41. false

复制代码

Map集合的实现类：HashMap，Hashtable，TreeMap
HashMap类

<ul>运行效率高，线程不安全；运行使用null作为key或者value
实现Map
存储结构：哈希表
区别于hashset（默认容量10，但是元素个数