java基础——集合框架

第一讲：集合框架(体系概述)

一，为什么出现集合：面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

二，数组和集合的不同：数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

三，集合类的特点：集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

四，集合中存储的都是对象的引用（地址）。

集合类的关系图：

第二讲：集合框架(共性方法)

一，Collection类的了解：

二，Collection 有两个常用子接口 List（列表）和 Set（集合）。

1. 1. List：元素是有序的，元素可以重复。因为该集合体系有索引
  2. Set：元素是无序的，元素不可以重复。

 1 import java.util.*;
 2 
 3 
 4 public class CollectionDemo {
 5                     public static void main(String[] args) {
 6                                 
 7                                 //创建结合
 8                                 ArrayList list = new ArrayList();
 9                                 
10                                 //向结合中添加元素
11                                 list.add("Object1");
12                                 
13                                 list.add("Object2");
14                                 
15                                 list.add("Object3");
16                                 
17                                 list.add("Object4");
18                                 
19                                 //添加重复元素
20                                 list.add("Object4");
21                                 
22                                 //打印集合
23                                 System.out.println(list);
24                                 
25                                 //打印集合的大小
26                                 System.out.println("list.size()::"+list.size());
27                                 
28                                 //删除元素
29                                 list.remove("Object1");
30                                 
31                                 System.out.println("删除后："+list);
32                                 
33                                 //判断元素
34                                 System.out.println("Object3是否存在："+list.contains("Object3"));
35                                 
36                                 //创建集合
37                                 ArrayList list2 = new ArrayList();
38                                 
39                                 //添加元素
40                                 list2.add("Object2");
41                                 
42                                 list2.add("Object3");
43                                 
44                                 list2.add("Object6");
45                                 
46                                 //list中只保留而这的共同元素
47                                 list.retainAll(list2);
48                                 
49                                 System.out.println(list);
50                                 
51                                 System.out.println(list2);
52                     }
53 }

第三讲：168_集合框架(迭代器)

一，接口Iterator的认识：

1. 1. public interface Iterator<E> 对 collection 进行迭代的迭代器。迭代器允许调用者利用定义良好的语义在迭代期间从迭代器所指向的 collection 移除元素。
  2. 方法：boolean hasNext() 如果仍有元素可以迭代，则返回 true。
  3. 方法：E next() 返回迭代的下一个元素。
  4. 方法：void remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素。每次调用 next 只能调用一次此方法。

二，Collection 继承自接口 Iterable<E>

Iterable<E> 接口拥有方法：Iterator<T> iterator() 返回一个在一组 T 类型的元素上进行迭代的迭代器。

三，迭代器介绍：

1. 迭代是取出集合中元素的一种方式。
2. 因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

 1 import java.util.*;
 2 
 3 
 4 public class Collection_Iterator {
 5                 public static void main(String[] args) {
 6                             
 7                     //创建结合
 8                     ArrayList list = new ArrayList();
 9                     
10                     //向结合中添加元素
11                     list.add("Object1");
12                     
13                     list.add("Object2");
14                     
15                     list.add("Object3");
16                     
17                     list.add("Object4");
18                     
19                     //获取迭代器，用于取出集合中的元素
20                     for(Iterator iterator = list.iterator();iterator.hasNext();){
21                         System.out.println(iterator.next());
22                     }
23                 }
24 }

第四讲：169_集合框架(List集合共性方法)

一，List 类的简单了解（凡是可以操作脚标的方法都是该体系特有的方法）：

增：void add(int index, E element) 在列表的指定位置插入指定元素。将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（在其索引中加 1）。
增：boolean addAll(int index,Collection<? extends E> c) 将指定 collection 中的所有元素都插入到列表中的指定位置。
删：E remove(int index）移除列表中指定位置的元素。
改：E set(int index, E element) 用指定元素替换列表中指定位置的元素。
查：E get(int index) 返回列表中指定位置的元素。
查：List<E> subList(int fromIndex, int toIndex) 返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图。
其他：ListIterator<E> listIterator() 返回此列表元素的列表迭代器（按适当顺序）。
其他：int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

二，代码练习：

 1 import java.util.*;
 2 public class Collection_List {
 3                 public static void main(String[] args) {
 4                             
 5                     //创建结合
 6                     ArrayList list = new ArrayList();
 7                     
 8                     //向结合中添加元素
 9                     list.add("Object1");
10                     
11                     list.add("Object2");
12                     
13                     list.add("Object4");
14                     
15                     list.add("Object3");
16                     
17                     System.out.println(list);
18                     
19                     //在指定位置添加元素
20                     list.add(0,"One");
21                     
22                     System.out.println(list);
23                     
24                     //删除指定位置的元素
25                     list.remove(1);
26                     
27                     System.out.println(list);
28                     
29                     //修改元素
30                     list.set(2, "Three");
31                     
32                     System.out.println(list);
33                     
34                     //通过脚标获取元素
35                     System.out.println("get(1)--"+list.get(1));
36                     
37                     //List集合的遍历取出方式
38                     for(int i=0 ; i<list.size();i++){
39                         System.out.println("list["+i+"]"+list.get(i));
40                     }
41                     
42                     //list的迭代器取出方式
43                     for(Iterator iterator = list.iterator() ;iterator.hasNext();){
44                         System.out.println(iterator.next());
45                     }
46                     
47                 }
48 }

第五讲：170_集合框架(ListIterator)

一，ListIterator 类的了解（List 集合特有的迭代器，是Iterator的子接口)：

二，在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。

========ListIterator 的最大特点是：可以实现在遍历过程中的增、删、改、查=========

三，代码练习：

 1 import java.util.*;
 2 
 3 public class Collection_ListIterator {
 4                 public static void main(String[] args) {
 5                             
 6                     //创建结合
 7                     ArrayList list = new ArrayList();
 8                     
 9                     //向结合中添加元素
10                     list.add("Object1");
11                     
12                     list.add("Object2");
13                     
14                     list.add("Object4");
15                     
16                     list.add("Object3");
17                     
18                     System.out.println(list);
19                     
20                     
21                     //获取列表迭代器
22                     ListIterator iterator = list.listIterator();
23                     
24                     while (iterator.hasNext()){
25                         
26                         //获取下一个元素
27                         Object obj = iterator.next();
28                         
29                         //判断
30                         if(obj.equals("Object2")){
31                             
32                             //在指定元素之后加入元素
33                             iterator.add("Tow");
34                         }
35                         
36                         if(obj.equals("Object4")){
37                             //修改指定元素
38                             iterator.set("four");
39                         }
40                     }
41                     
42                     
43                     System.out.println(list);
44                     
45                     
46                     //判断是否有后一个元素
47                     System.out.println("hasNext()"+iterator.hasNext());
48                     
49                     //判断是否有前一个元素
50                     System.out.println("hasPrevious()"+iterator.hasPrevious());
51                     
52                     //逆向遍历
53                     while(iterator.hasPrevious()){
54                         System.out.println(iterator.previous());
55                     }
56                 }
57 }

第六讲，第七讲：171_集合框架(List集合具体对象的特点)

一， List 的常见子类对象：

1. ArrayList 底层的数据结构使用的是数组结构。特点：查询元素很快，增加删除元素稍慢（元素越多速度越慢）。====注：默认容量为10，50%延长====
2. LinkedList 底层使用的是链表数据结构。特点：增删速度很快，查询速度稍慢。
3. Vector 底层是数组数据结构。特点：Vector 是同步的。（ArrayList 替代）。===注：默认容量为10，100%延长===

二，枚举 Enumeration （枚举和迭代式一样的，因为枚举的名称过长被迭代取代，枚举是Vector特有的迭代方法）

方法：boolean hasMoreElements() 测试此枚举是否包含更多的元素。
E nextElement() 如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

三，代码练习：

 1 import java.util.*;
 2 
 3 public class VectorDemo {
 4                 public static void main(String[] args) {
 5                             
 6                             Vector v = new Vector();
 7                             
 8                             v.add("Object1");
 9                             v.add("Object2");
10                             v.add("Object3");
11                             
12                             Enumeration enu = v.elements();
13                             while(enu.hasMoreElements()){
14                                 System.out.println(enu.nextElement());
15                             }
16                 }
17 }

第八讲，第九讲：173_集合框架(LinkedList)

一，LinekList 了解：

1. public class LinkedList<E>extends AbstractSequentialList<E>implements List<E>, Deque<E>, Cloneable, Serializable List 接口的链接列表实现。
2. 1、增
  
          addFirst();
  
          addLast();
  
  2、获取，获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
  
          getFirst();
  
          getLast();
  
  3、删，获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException
  
         removeFirst();
  
         removeLast();
  
  在JDK1.6以后，出现了替代方法。
  
  1、增
  
          offFirst();
  
        offLast();
  
  2、获取，获取元素，但是不删除。如果集合中没有元素，会返回null。
  
          peekFirst();
  
          peekLast();
  
  3、删，获取元素，并删除元素。如果集合中没有元素，会返回null。
  
          pollFirst();
  
          pollLast();

二，代码练习：

 1 import java.util.*;
 2 
 3 public class LinkedListDemo {
 4                 public static void main(String[] args) {
 5                             
 6                             //创建Linked列表
 7                             LinkedList list = new LinkedList();
 8                             
 9                             //增加元素
10                             list.addFirst("Object1");
11                             list.addFirst("Object2");
12                             list.addFirst("Object3");
13                             list.addFirst("Object4");
14                             
15                             //输出列表
16                             System.out.println(list);
17                             
18                             //在最后的位置增加元素
19                             list.addLast("Object5");
20                             
21                             //输出列表
22                             System.out.println(list);
23                             
24                             //分别获取列表的第一个元素和最后一个元素
25                             System.out.println(list.getFirst());
26                             System.out.println(list.getLast());
27                             
28                             //获取并删除第一个元素
29                             System.out.println(list.removeFirst());
30                             
31                             //列表的大小
32                             System.out.println(list.size());
33                             
34                             //获取并删除所有元素
35                             while(!list.isEmpty()){
36                                 System.out.println(list.removeFirst());
37                             }
38                 }
39 }

三，练习目标：使用LinkedList 模拟一个堆栈或者队列数据结构。

1. 堆栈：先进后出。
2. 队列：先进先出。

 1 import java.util.*;
 2 
 3 
 4 //定义队列实现先进先出
 5 class Queue{
 6     
 7     //实际实现
 8     LinkedList list = null;
 9     
10     //构造方法
11     public Queue(){
12         list = new LinkedList();
13     }
14     
15     //在尾部增加元素
16     public boolean myAdd(Object obj){
17         return list.add(obj);
18     }
19     
20     //获取最先增加的元素
21     public Object myGet(){
22         return list.removeFirst();
23     }
24     
25     //是否为空
26     public boolean isNull(){
27         return list.isEmpty();
28     }
29 }
30 
31 
32 
33 public class LinkedListTest {
34             public static void main(String[] args) {
35                             
36                             Queue queue = new Queue();
37                             
38                             queue.myAdd("Object1");
39                             queue.myAdd("Object2");
40                             queue.myAdd("Object3");
41                             queue.myAdd("Object3");
42                             
43                             System.out.println(queue.list);
44                             while(!queue.isNull()){
45                                 System.out.println(queue.myGet());
46                             }
47             }
48 }

第十讲，十一讲：175_集合框架(ArrayList练习)

一，练习目标：去除ArrayList中重复的元素。

二，思路：

1. 创建一个新的临时容器。
2. 将旧容器中的元素向心容器中加入，加入之前判断是否有该对象。
3. 若没有，则加入，若有，则跳过。
4. 用新容器替换旧容器。

三，练习代码：

 1 import java.util.*;
 2 
 3 public class ArrayListTest {
 4                 public static void main(String[] args) {
 5                         
 6                         ArrayList list = new ArrayList();
 7                         
 8                         list.add("Object1");
 9                         list.add("Object1");
10                         list.add("Object2");
11                         list.add("Object2");
12                         list.add("Object3");
13                         list.add("Object3");
14                         
15                         System.out.println(list);
16                         
17                         list = singleElement(list);
18                         
19                         System.out.println(list);
20                 }
21                 
22                 
23                 //创建方法，返回没有重复元素的集合
24                 public static ArrayList singleElement(ArrayList list){
25                     
26                     //临时集合
27                     ArrayList temp = new ArrayList();
28                     
29                     //遍历集合，添加没有重复的元素
30                     for(Iterator iterator = list.iterator();iterator.hasNext();){
31                         Object obj = iterator.next();
32                         //是否重复
33                         if(temp.contains(obj))
34                             continue;
35                         
36                         //不重复
37                         temp.add(obj);
38                     }
39                     
40                     return temp;
41                 }
42 }

四，练习目标：将自定义对象作为元素存储到ArrayList集合中，并去除重复元素

五，思路：

1. 对人描述，将数据封装到人对象中。
2. 定义容器将人对象进行存储。
3. 去除重复。

六，代码练习：

 1 import java.util.*;
 2 
 3 
 4 //定义Person类
 5 class Person{
 6         private String name = null;
 7         private int age ;
 8         
 9         public Person(String name,int age){
10             this.name = name;
11             this.age = age;
12         }
13         
14         public String getName(){
15             return this.name;
16         }
17         
18         public int getAge(){
19             return this.age;
20         }
21 
22 
23         @Override
24         public boolean equals(Object obj) {
25             if (this == obj)
26                 return true;
27             if (obj == null)
28                 return false;
29             if (getClass() != obj.getClass())
30                 return false;
31             Person other = (Person) obj;
32             if (age != other.age)
33                 return false;
34             if (name == null) {
35                 if (other.name != null)
36                     return false;
37             } else if (!name.equals(other.name))
38                 return false;
39             return true;
40         }
41         
42         @Override
43         public String toString(){
44             return this.name+"--"+this.age;
45         }
46 }
47 public class ArrayListTest_Person {
48     
49             public static void main(String[] args) {
50                 
51                     //创建List结合，
52                     ArrayList list = new ArrayList();
53                     
54                     //添加元素
55                     list.add(new Person("lisi",23));
56                     list.add(new Person("wangwu",34));
57                     list.add(new Person("zhaoliu",22));
58                     list.add(new Person("lisi",23));
59                     list.add(new Person("wangwu",34));
60                     
61                     list.add(null);
62                     list.add(null);
63                     
64                     //输出
65                     System.out.println(list);
66                     
67                     //去除重复
68                     list = singleElement(list);
69                     
70                     //输出
71                     System.out.println(list);
72             }
73             
74             
75             //创建方法，返回没有重复元素的集合
76             public static ArrayList singleElement(ArrayList list){
77                 
78                 //临时集合
79                 ArrayList temp = new ArrayList();
80                 
81                 //遍历集合，添加没有重复的元素
82                 for(Iterator iterator = list.iterator();iterator.hasNext();){
83                     Object obj = iterator.next();
84                     //是否重复
85                     if(temp.contains(obj))
86                         continue;
87                     
88                     //不重复
89                     temp.add(obj);
90                 }
91                 
92                 return temp;
93             }
94 }

第十二讲，十三讲：177_集合框架(HashSet)

一，Set集合的了解（ Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。）：

1. Set集合的功能和Collection是一致的。===注：线程非同步===
2. 常见子类：HashSet 底层数据结构是 Hash 表。通过hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。
3. 常见子类：TreeSet 底层数据结构为二叉树。

二，练习：往HashSet中存入自定义对象：

 1 import java.util.*;
 2 
 3 //定义Person类
 4 class Person{
 5         private String name = null;
 6         private int age ;
 7         
 8         public Person(String name,int age){
 9             this.name = name;
10             this.age = age;
11         }
12         
13         public String getName(){
14             return this.name;
15         }
16         
17         public int getAge(){
18             return this.age;
19         }
20 
21 
22         @Override
23         public int hashCode() {
24             final int prime = 31;
25             int result = 1;
26             result = prime * result + age;
27             result = prime * result + ((name == null) ? 0 : name.hashCode());
28             System.out.println(this.name+"--"+result);
29             return result;
30         }
31 
32         @Override
33         public boolean equals(Object obj) {
34             if (this == obj)
35                 return true;
36             if (obj == null)
37                 return false;
38             if (getClass() != obj.getClass())
39                 return false;
40             Person other = (Person) obj;
41             if (age != other.age)
42                 return false;
43             if (name == null) {
44                 if (other.name != null)
45                     return false;
46             } else if (!name.equals(other.name))
47                 return false;
48             return true;
49         }
50         
51         @Override
52         public String toString(){
53             return this.name+"--"+this.age;
54         }
55 }
56 
57 public class HashSetTest {
58                     public static void main(String[] args) {
59                             //创建集合    
60                             HashSet set = new HashSet();
61                             //加入元素
62                             set.add(new Person("lisi",44));
63                             set.add(new Person("wangwu",55));
64                             set.add(new Person("zhaoliu",66));
65                             //重复元素的加入
66                             set.add(new Person("lisi",44));
67                             //遍历
68                             for(Iterator iterator = set.iterator(); iterator.hasNext();){
69                                 Person p = (Person)iterator.next();
70                                 System.out.println(p);
71                             }
72                     }
73 }

=====注：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。=====

第十五讲，十六讲：集合框架(TreeSet)，(TreeSet存储自定义对象)

一，TreeSet 特点：

1. 可以对集合中的元素进行排序。
2. 对于存入其中的对象必须实现Comparable接口，不然会发生异常。
3. 元素唯一性的根据：CompareTo() 方法若返回 0 则表示两个元素重复。

二，Comparable 接口的简单了解：

public interface Comparable<T> 此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。
方法：int compareTo(T o) 比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

三，代码练习：

 1 import java.util.*;
 2 
 3 public class TreeSetDemo_Student {
 4             public static void main(String[] args) {
 5                 
 6                 //创建TreeSet集合，
 7                 TreeSet set = new TreeSet();
 8                 
 9                 //通过排序，有序增加成员
10                 set.add(new Student("lisi",12));
11                 set.add(new Student("wangwu",16));
12                 set.add(new Student("zhaoliu",15));
13                 
14                 //遍历输出
15                 for(Iterator iterator = set.iterator();iterator.hasNext();){
16                     System.out.println(iterator.next());
17                 }
18             }
19 }
20 
21 //定义学生类，实现Compareable接口
22 class Student implements Comparable{
23         private String name;
24         private int age;
25         
26         public Student(String name,int age){
27             this.name = name;
28             this.age = age;
29         }
30         
31         public String getName(){
32             return this.name;
33         }
34         
35         public int getAge(){
36             return this.age;
37         }
38         
39         @Override
40         public int compareTo(Object obj){
41             Student stu = (Student) obj;
42             if(this.age>stu.age)
43                 return 1;
44             else if(this.age < stu.age)
45                 return -1;
46             else if(this.age == stu.age)
47                 return this.name.compareTo(stu.name);
48             return 0;
49         }
50         
51         @Override
52         public String toString(){
53             return this.name+"---"+this.age;
54         }
55 }

第十七讲：黑马程序员_毕向东_Java基础视频教程第15天-03-集合框架(二叉树)

二叉树排序示意图：

第十八讲，十九讲：集合框架(实现Comparator方式排序)，(TreeSet练习)

一，TreeSet的第二种排序方式： ===注：当两种排序都存在时，以比较器为主。====

1. 当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
2. 比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。
3. 在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

二，接口Comparator 的了解：

1. public interface Comparator<T> 强行对某个对象 collection 进行整体排序 的比较函数。
2. int compare(T o1, T o2) 比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
3. boolean equals(Object obj) 指示某个其他对象是否“等于”此 Comparator。

三，代码练习：

 1 import java.util.*;
 2 
 3 public class TreeSetDemo_Comparator {
 4             public static void main(String[] args) {
 5                     
 6                     //构造方法中传入Comparator对象
 7                     TreeSet set = new TreeSet(new Comp());
 8                     
 9                     //添加元素
10                     set.add(new Techer("lisi",23));
11                     set.add(new Techer("zhaoliu",89));
12                     set.add(new Techer("zhaoliu",98));
13                     set.add(new Techer("zhaoliu",98));
14                     set.add(new Techer("anning",20));
15                     
16                     //遍历输出
17                     for(Iterator iterator = set.iterator();iterator.hasNext();){
18                         System.out.println(iterator.next());
19                     }
20             }
21 }
22 
23 
24 //自定义比较器
25 class Comp implements Comparator{
26                 
27             @Override
28             public int compare(Object obj1,Object obj2){
29                     
30                     Techer tech1 = (Techer) obj1;
31                     Techer tech2 = (Techer) obj2;
32                     
33                     int num = 0 ;
34                     num = tech1.getName().compareTo(tech2.getName());
35                     
36                     if(num==0){
37                         return tech1.getAge()-tech2.getAge();
38                     }
39                     return num;
40             }
41 }
42 
43 //定义一个类，没有实现Comparable接口
44 class Techer{
45     private String name;
46     private int age;
47     
48     public Techer(String name,int age){
49         this.name = name;
50         this.age = age;
51     }
52     
53     public String getName(){
54         return this.name;
55     }
56     
57     public int getAge(){
58         return this.age;
59     }
60     
61     @Override
62     public String toString(){
63         return this.name+"--"+this.age;
64     }
65     
66 }

四，练习要求：按照字符串的长度排序：

 1 import java.util.*;
 2 
 3 public class TreeSet_String {
 4             public static void main(String[] args) {
 5                     
 6                     TreeSet set = new TreeSet(new Comp_Len());
 7                     
 8                     
 9                     set.add("bdf");
10                     set.add("abc");
11                     set.add("a");
12                     set.add("bcd");
13                     set.add("bdf");
14                     
15                     System.out.println(set);
16             }
17 }
18 
19 class Comp_Len implements Comparator{
20         
21         @Override
22         public int compare(Object obj1,Object obj2){
23                     String str1 = (String) obj1;
24                     String str2 = (String) obj2;
25                     
26                     int num = 0;
27                     num = str1.length()-str2.length();
28                     if(num==0){
29                         return str1.compareTo(str2);
30                     }
31                     
32                     return num;
33         }
34 }

相关阅读:
CSS笔记
 WebStorm快捷键
 单例模式详解
 JS正则表达式
 Java NIO 详解（二）
Java NIO 详解（一）
【Java并发编程】之十六：深入Java内存模型——happen-before规则及其对DCL的分析（含代码）
Go 普通LOG输出
 Go TCP网路程序编写
 Go 语言官方包函数中文翻译
原文地址：https://www.cnblogs.com/xiaochongbojue/p/4033239.html