java集合框架

1.1教学目标

1. 集合的概念
2. Collection接口
3. List接口与实现类
4. 泛型和工具类
5. Set接口与实现类
6. Map接口与实现类

1.2 集合

对象的容器，实现了对对象常用的 *** 作，类似数组的功能。

和数组的区别：

1. 数组长度固定，集合长度不固定
2. 数组可以存储基本类型和引用类型，集合只能引用类型
3. 位置：java.util.*

1.3 Collection 体系集合

Collection : 该体系结构的跟接口，代表一组对象，称为“集合”；

List接口的特点：有序，有下标、元素可重复

Set结构的特点：无序，无下标、元素不能重复

Collection 父接口

特点：代表一组任意类型的对象，无序、无下标、不能重复

方法：

1. boolean add(Object objc)//添加一个对象
2. boolean addAll(Collection c )//将一个集合中的所有对象添加到此集合中。
3. void clear() /清空此集合中的所有对象。
4. boolean contains(Object o)//检查此集合中是否包含o对象
5. boolean equals(Object o )//比较此集合是否与指定对象相等
6. boolean isEmpty() //判断此集合是否为空
7. boolean remove(Object o) //在此集合中移除0对象
8. int size() //返回此集合中的元素个数
9. Object[] toArray() //将此集合转换成数组

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

    public static void main(String[] args) {
        //创建一个集合
        Collection objects = new ArrayList();
        //1.添加元素
        objects.add("苹果");
        objects.add("西瓜");
        objects.add("榴莲");
        System.out.println(objects.size());
        System.out.println(objects);
        //2.删除元素
        objects.remove("榴莲");
        System.out.println(objects.size());
        System.out.println(objects);
        //3.清空
//        objects.clear();
//        System.out.println(objects);
        //4 遍历元素【重点】
        //4.1 使用增强for
        for (Object object:objects
             ) {
            System.out.println(object);

        }
        //4.2使用迭代器(迭代器专门用来遍历集合的一种方法)
        Iterator<Object> it = objects.iterator();
        while (it.hasNext()){
            String next = (String) it.next();
            System.out.println(next);
            it.remove();
        }
        System.out.println(objects.size());
        //5 判断

        System.out.println(objects.contains("西瓜"));
        System.out.println(objects.isEmpty());


    }

---

public class Student {
    public String name;
    public String age;

    public Student(String name, String age) {
        this.name = name;
        this.age = age;
    }

    public Student(String name) {
        this.name = name;
    }

    public Student() {
    }
}

public class demo2 {
    public static void main(String[] args) {
        Collection xuelist = new ArrayList<>();
        Student 张三 = new Student("张三", "18");
        Student 李四 = new Student("李四", "20");
        Student 王五 = new Student("王五", "31");
        //1添加数据
        xuelist.add(张三);
        xuelist.add(李四);
        xuelist.add(王五);
        System.out.println(xuelist.size());
//        System.out.println(xuelist.toString());
        //2 删除
        xuelist.remove(王五);
        System.out.println(xuelist.size());
        //3遍历
        //3.1 增加for
        for (Object object:xuelist
             ) {
            Student s=(Student) object;
            System.out.println(s.name );

        }
        //3.2 迭代器：hasNext() Next();remove();迭代过程不能使用Collection删除方法
        Iterator<Object> it = xuelist.iterator();
        while (it.hasNext()){
            Student next = (Student) it.next();
            System.out.println(next.age);
        }
        //4判断
        System.out.println(xuelist.contains(张三));//true
        System.out.println(xuelist.contains(new Student("张三", "18")));//false

    }
}

List集合使用

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

方法：

1. void add(int index，Object o)//在index位置插入对象o

2. boolean addAll(int index,Collection c)//将一个集合中的元素添加到此集合中index位置

3. Object get(int index) //返回集合中指定位置的元素

4. List subList(int fromIndex,int toIndex) //返回fromIndex和to Index之间的集合元素。

package base;

import java.util.*;

public class demo2 {
    public static void main(String[] args) {
        //1 先创建集合对象
        List arrlist = new ArrayList();
        //2 添加对象
        arrlist.add("苹果");
        arrlist.add("菠萝");
        arrlist.add(0,"西瓜");
        System.out.println(arrlist);
        System.out.println(arrlist.toString());
        //3 删除元素
        arrlist.remove(0);
        System.out.println(arrlist);
        //4 遍历
        //4.1 用for遍历
        for (int i = 0; i < arrlist.size(); i++) {
            System.out.println(arrlist.get(i));

        }
        System.out.println("=======");
        //4.2 使用增强for
        for (Object x:arrlist
             ) {
            System.out.println((String)x);
        }
        System.out.println("=====使用迭代器");
        //4.3 使用迭代器
        Iterator it = arrlist.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4.4 列表迭代器
        System.out.println("===列表迭代器");
        ListIterator it2 = arrlist.listIterator();
        System.out.println("====从前往后");
        while (it2.hasNext()){
            System.out.println(it2.nextIndex()+":"+it2.next());
        }
        System.out.println("====从后往前");
        while (it2.hasPrevious()){
            System.out.println(it2.previousIndex()+":"+it2.previous());
        }
        System.out.println("=====5判断");
        //5 判断
        System.out.println(arrlist.contains("苹果"));
        System.out.println(arrlist.isEmpty());
        //6 获取位置
//        System.out.println("======6获取位置");
        System.out.println(arrlist.indexOf("华为"));//没有，返回-1
 

    }
}

    public static void main(String[] args) {
        //1 创建集合
        List list = new ArrayList();
        //2 添加数字数据
        list.add(20);
        list.add(30);
        list.add(10);
        list.add(21);
        list.add(20);
        System.out.println(list);//[20, 30, 10, 21, 20]
        //2 删除 *** 作
        list.remove(new Integer(30));
        System.out.println(list);//[20, 10, 21, 20]
        //3 subList：返回子集合
        List list1 = list.subList(2, 4);
        System.out.println(list1);

    }

List实现类

1. Arraylist 重点

   优点：数组结构实现，查询快，增删慢

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

   源码分析：

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

   • 存放元素的数组elementData

   • 实际的元素个数size

   • 空数组 DEFAULTCAPACITY_EMPTY_ELEMENTDATA

2. Vector：

   优点：数组结构实现，查询快，增删慢

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

3. LinkedList

   优点：链表结构实现，增删快，查询慢

ArrayList 代码

package base;
/*
* ArrayList的使用
* 存储结构：数组，查找遍历速度快，增删慢
* */

import java.util.*;

public class demo2 {
    public static void main(String[] args) {
        //创建集合
        ArrayList arrayList = new ArrayList<>();
        Student 刘德华 = new Student("刘德华", "20");
        Student 梁朝伟 = new Student("梁朝伟", "22");
        Student 郭富城 = new Student("郭富城", "18");
//        1. 添加元素
        arrayList.add(刘德华);
        arrayList.add(梁朝伟);
        arrayList.add(郭富城);
        System.out.println(arrayList.toString());
        System.out.println(arrayList.size());
        //2. 删除元素
        arrayList.remove(new Student("刘德华","20"));
        System.out.println(arrayList);
        //3. 遍历元素[重点]
        //3.1 使用迭代器
        System.out.println("======迭代器");
        Iterator it = arrayList.iterator();
        while (it.hasNext()){
            Student s1=(Student) it.next();
            System.out.println(s1);
        }
        //3.2 使用列表迭代器
        System.out.println("======列表迭代器");
        ListIterator it2 = arrayList.listIterator();
        while (it2.hasNext()){
            Student s3=(Student)it2.next();
            System.out.println(s3.toString());
        }
        //4 判断
        System.out.println(arrayList.contains(new Student("你好啊", "90")));

        //5 查找
        System.out.println(arrayList.indexOf(new Student("梁朝伟", "22")));


    }
}

LinkedList代码

package base;
/*
* LinedList的使用
* 存储结构：双向链表
* */

import java.util.*;

public class demo2 {
    public static void main(String[] args) {
        //创建集合
        LinkedList linkedlist = new LinkedList<>();
        //1添加元素
        Student 刘德华 = new Student("刘德华", "20");
        Student 梁朝伟 = new Student("梁朝伟", "22");
        Student 郭富城 = new Student("郭富城", "18");
        linkedlist.add(刘德华);
        linkedlist.add(梁朝伟);
        linkedlist.add(郭富城);
        linkedlist.add(郭富城);
        linkedlist.add(郭富城);
        System.out.println(linkedlist.size());
        //2 删除
        linkedlist.remove(郭富城);
        //3.1  for遍历
        for (int i = 0; i < linkedlist.size(); i++) {
            System.out.println(linkedlist.get(i));
        }
        //3.2  增加for
        System.out.println("=======增强for");
        for (Object x:linkedlist
             ) {
            Student s=(Student) x;
            System.out.println(s.toString());
        }
        //3.3 使用迭代器
        System.out.println("========使用迭代器");
        Iterator it = linkedlist.iterator();
        while (it.hasNext()){
            Student s1=(Student) it.next();
            System.out.println(s1.toString());
        }
        //3.4 列表迭代器
        System.out.println("=========列表迭代器");
        ListIterator it2 = linkedlist.listIterator();
        while (it2.hasNext()){
            Student s2=(Student) it2.next();
            System.out.println(s2.toString());
        }
        //4 判断
        System.out.println(linkedlist.contains(刘德华));
        System.out.println(linkedlist.isEmpty());
        //5 获取索引
        System.out.println(linkedlist.indexOf(郭富城));
    }
}

ArrayList 和 LinkedList 实现区别

1. ArrayList 创建，实际开辟的是一个连续的空间，有下角标indexof

2. LinkedList : 开辟的是随机的空间，通过指针牵引

1.4 泛型

1. Java 泛型是JDK1.5 中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
2. 常见类型有泛型类、泛型接口、泛型方法。
3. 语法：
   T 称为类型占位符，表示一种引用类型。
4. 好处：
   • 提高代码的重用性
   • 放置类型转换异常，提高代码的安全性

泛型类：注意泛型只能使用引用类型；不同泛型对象之间不能相互复制

//class Demo2
package base;
/*
* 泛型类
* 语法：类名
* T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开
* */

public class Demo2<T> {
 //使用泛型T
 //1创建变量
 T t;
 public String name;
 //2 添加方法,作为方法的参数
 public void show(T t){
     System.out.println(t);
 }
 //3 泛型作为方法的返回值
 public T getT(){
     return t;
 }
 public void getName(){
     System.out.println(name);
 }

}


//class TestGeneric
package base;

public class TestGeneric {
 public static void main(String[] args) {
     //使用泛型类创建对象
     Demo2<String> demo2 = new Demo2<>();
     demo2.t="你好";
     System.out.println(demo2.getT());
     demo2.getName();
     System.out.println("==========");
     Demo2<Integer> int1 = new Demo2<>();
     int1.t=1314;
     int1.show(520);
     System.out.println(int1.getT());
   
   
   //不同泛型类对象之间不能相互复制
   Demo2<String> domo3=int1 ;
   //但是可以同类型之间复制
   Demo2<Integer> domo3=int1 ;
 }
}

泛型接口

//class MyInterface
package base;
/*
* 泛型接口
* 语法：接口名
* 注意：不能泛型静态常量
* */
public interface MyInterface<T> {
    String name="张三";
    T server(T t);
}

//class MyInterfaceImpl
package base;

public class MyInterfaceImpl<T> implements MyInterface<String> {
    @Override
    public String server(String s) {
        System.out.println("实现接口方法");
        return null;
    }

    public static void main(String[] args) {
        MyInterfaceImpl<String> myInterface = new MyInterfaceImpl();
        myInterface.server("1");
    }
}

泛型方法

//class MyInterface
package base;
/*
* 泛型方法
* 语法： 方法名
* */
public class MyInterface {
    public <T> T show(T t){
        System.out.println("泛型方法："+t);
        return t;
    }
}


//class MyInterfaceImpl
package base;

public class MyInterfaceImpl {
    public static void main(String[] args) {
        MyInterface myinter = new MyInterface();
        myinter.show("String");
        myinter.show(1000);
        myinter.show(12.2f);


    }

}

泛型集合

1. 概念：参数化类型、类型安全的集合，强制集合元素的类型必须一直。
2. 特点：
   • 编译时即可检查，而非运行时抛出异常。
   • 访问时，不必类型转换（拆箱）。
   • 不同泛型之间不能相互复制，泛型不存在多态。

1.5 Set集合

1. 特点：无序、无下标、元素不可重复。
2. 方法：全部继承自Collection中的方法。

Set实现类

1. HashSet**（重点）**

   • 基于HashCode实现元素不重复。
   • 当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入

2. TreeSet：

   • 基于排列顺序实现元素不重复
   • 实现了SortedSet接口，对集合元素自动排序。
   • 元素对象的类型实现Comparable接口，指定排序规则。
   • 通过CompareTo方法确定是否为重复元素。

//其他方法跟之前的Array差不多
public static void main(String[] args) {
        //创建集合
        Set<String> set = new HashSet<>();
        //1添加数据
        set.add("苹果");
        set.add("华为");
        set.add("小米");
        set.add("小米");
        set.add("苹果");
        System.out.println(set.size());
        System.out.println(set.toString());
    }

HashSet集合的使用

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

存储过程：1、根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空执行第二步

​ 2、再执行equals方法，如果equals方法为true，则认为是重复的

    public static void main(String[] args) {
        //创建集合
        Set<String> set = new HashSet<>();
        //1添加数据
        set.add("苹果");
        set.add("华为");
        set.add("小米");
        set.add("小米");
        set.add("苹果");
        System.out.println(set.size());
        System.out.println(set.toString());

TreeSet的使用

使用TreeSet保存数据

存储结构：红黑树

要求：元素必须要实现Comparable接口，compareTo()方法返回值为0，认为是重复元素

    public static void main(String[] args) {
        //创建集合
        TreeSet<String> set = new TreeSet<>();
        //1添加数据
        set.add("苹果");
        set.add("华为");
        set.add("小米");
        set.add("小米");
        set.add("苹果");
        System.out.println(set.size());
        System.out.println(set.toString());

Comparator：TreeSet接口

1. Comparator 实现定制比较（比较器）TreeSet集合的使用
2. Comparable:可比较的

public class Demo01 {
   public static void main(String[] args) {
       //创建集合，并指定比较规则
       TreeSet<Student> treeset = new TreeSet<>(new Comparator<String>() {
           @Override
           public int compare(String o1, String o2) {
               int n1=o1.getAge()-o2.getAge();
               int n2=o1.getName().compareTo(o2.getName());
               return n1==0?n2:n1;
           }
       });

       Student s1=new Student("XYZ","20");
       Student s2=new Student("hello","22");
       Student s3=new Student("zhangsan","25");
       treeset.add(s1);
       treeset.add(s2);
       treeset.add(s3);
       System.out.println(treeset.toString());

   }
}

1.6 Map集合

Map接口的特点：

1. 用于存储任意键值对(Key-Value)
2. 键：无序，无下标、不允许重复（唯一值）
3. 值：无序、无下标、允许重复

Map父接口

特点：存储一对数据(Key-Value)，无序、无下标、键不可重复，值可以重复

方法： V put（K key,V value） //将对象存入到集合中，关联键值。key重复则覆盖原值

​ Object get(Object key) //根据键获取对应的值

​ Set //返回所有key

​ Collection values() //返回包含所有值的Collection集合

​ set> //键值匹配的Set集合。

public class Demo01 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String, String> mp = new HashMap<>();
        //1.添加元素
        mp.put("cn", "china");
        mp.put("uk", "brnsh");
        mp.put("usa", "American");
        System.out.println(mp);//{usa=American, uk=brnsh, cn=china}
        System.out.println(mp.size());//3
        //2 删除
        mp.remove("cn");
        System.out.println(mp);//{usa=American, uk=brnsh}
        //3 遍历
        System.out.println("=========key迭代器+get");
//        Set keyset = mp.keySet();
//        Iterator it = keyset.iterator();
//        while (it.hasNext()){
//            System.out.println(it.next());
//        }
//        System.out.println("========for增强");
        for (String x : mp.keySet()) {
            System.out.println(x + "----" + mp.get(x));
        }

        System.out.println("=====使用entry迭代器");
        Set<Map.Entry<String, String>> entries = mp.entrySet();
        for (Map.Entry<String, String> x : entries) {
            System.out.println(x.getKey() + "---" + x.getValue());
        }
        //4 判断
        System.out.println(mp.containsKey("us"));
        System.out.println(mp.containsValue("brnsh"));
    }
}

Map集合的实现类

HashMap [重点]
JDK1.2版本，线程不安全，运行效率快；允许用null作为key或者value

public static void main(String[] args){
  //创建集合
  HashMap<String,String> students=new HaspMap<Student,String>();
  Student s1=new Student("孙悟空",100);
  Student s2=new Student("猪八戒",101);
  Student s3=new Student("沙和尚",102);
  students.put(s1,"北京");
  students.put(s2,"上海");
  students.put(s3,"南京");
  System.out.println("元素个数"+students.size());
  System.out.println(students.toString());
 //其他的同上


}

源码分析：

1 static final int DEFAULT_INITIAL_CAPACITY = 1<< 4;//HASHMAP初始容量大小
2 static final int MAXIMUM_CAPACITY =1 <<30;//hashmap的数组最大容量
3 static final float DEFAULT_LOAD_FACTOR =0.75f //默认加载因子
4 static final int TREEIFY_THRESHOLD =8;//JDK 1.8 当链表长度大于8时，调整成红黑树
5 static final int UNTREEIFY_THRESHOLD =6; JDK 1.8  当链表长度小于6时，调成链表
6 static fianl int MIN_TREEIFY_CAPACITY = 64; //JDK1.8 当链表长度大于8时，并且集合元素个数大于等于64时，调整成红黑树
7 transient Node<k,V>[] table ;//哈希表中的数组
8 size;//元素个数

总结：

（1）HashMap刚创建时，table是null,为了节省空间，当添加第一个元素时，table容量调整为16
（2）当元素个数大于阈值（16*0.75=12）时，会进行扩容，扩容后大小为原来的2倍。目的是减少调整元素的个数。
（3）jdk1.8 当每个链表长度大于8，并且元素个数大于等于64时，会调整为红黑树，目的是提供执行效率
（4）jdk1.8 当链表长度小于6时，调整成链表
（5）jdk1.8以前，链表时头插入，jdk1.8以后是尾插入

Hashtable

JDK 1.0 版本，线程安全，运行效率慢；不允许null作为key或者value。

Properties

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

TreeMap

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

1.7 Colletions工具类

概念：集合工具类，定义了除了存取以为的集合常用方法

//方法
public static void reverse(List<?> list) //反转集合中元素的顺序
public static void shuffle(List<?> list) //随机重置集合元素的顺序
public static void sort(List<T> list) //升序排序（元素类型必须实现Comparable接口）

    public static void main(String[] args) {
        ArrayList<Integer> arraylist = new ArrayList<>();
        arraylist.add(35);
        arraylist.add(20);
        arraylist.add(30);
        arraylist.add(40);
        System.out.println(arraylist);//[35, 20, 30, 40]
        Collections.sort(arraylist);
        System.out.println(arraylist);//[20, 30, 35, 40]
        //binarysearch
        int i = Collections.binarySearch(arraylist, 40);
        System.out.println(i);//3
        //copy 复制
        ArrayList<Integer> arraylist2 = new ArrayList<>();
        for (int j = 0; j < arraylist.size(); j++) {
            arraylist2.add(j);
        }
        Collections.copy(arraylist2,arraylist);//这个方法要求两个数组必须大小一样才可以拷贝。
        System.out.println(arraylist2);
        ArrayList<Integer> ceshi=arraylist2;
        System.out.println(arraylist.equals(arraylist2));//true
        System.out.println(ceshi.equals(arraylist2));//true
        System.out.println(ceshi.equals(arraylist));//true
        //说明，新创建一个拷贝，跟定义一个引用类型，实际是一样的
        //---------------
        //reverse反转
        Collections.reverse(arraylist);
        System.out.println(arraylist);//[40, 35, 30, 20]
        //shuffle打乱
        Collections.shuffle(arraylist);
        System.out.println(arraylist);//[30, 20, 35, 40]
    }

1.8数组与集合之间转换

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(23);
        list.add(15);
        list.add(19);
        list.add(20);
        System.out.println(list);//[23, 15, 19, 20]
        //List 转成数组
        Integer[] itshuzu = list.toArray(new Integer[0]);//这个长度给多少都行
        System.out.println(itshuzu.toString());
        //数组转成集合：注意这个集合是受限集合，不能添加和删除，因为他的长度固定了
        String[] names={"张三","李四","王五"};
        List<String> list2 = Arrays.asList(names);
        System.out.println(list2);
        //注意一个，int数组转集合
        int[] nums={100,200,300,400,30};
//        List num2 = Arrays.asList(nums);//会报错
        List<int[]> num2 = Arrays.asList(nums);//要写成这样，但是这样的集合，里面的元素类型都是数组
//        Integer[] nums={100,200,300,400,30};//或者前期定义时候这么定义

    }

1.9 集合总结

1. 集合的概念：

   对象的容器，和数组类似，定义了对多个对象进行 *** 作的常用方法。

2. List集合

   有序、有下标、元素可以重复（ArrayList、LinkedList，Vector）

3. Set集合

无序、无下标、元素不可重复（HashSet，TreeSet）

4. Map集合

存储一对数据，无序，无下标，键不可重复，值可重复。（HashMap，HashTable，TreeMap）

5. Collections

集合工具类，定义了除了存取以外的集合常用方法。