java集合框架学习笔记

思维导图

一、什么是集合

存放在java.util.*。是一个存放对象的容器。

存放的是对象的引用，不是对象本身
长度不固定
只能存放对象

二、collection接口

collection的使用

增加元素 add();
判断是否包含某个元素 contains();
删除某个元素 remove();
遍历元素（iterator迭代器）

package com.zheng.demo1;import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;public class MyCollection {public static void main(String[] args) {Collection c = new ArrayList();//增加元素c.add("足球");c.add("篮球球");c.add("乒乓球");//集合大小System.out.println("当前集合大小：" + c.size());//判断是否包含某个元素System.out.println(c.contains("足球"));//删除元素c.remove("足球");System.out.println("删除一个元素之后大小：" + c.size());System.out.println("===============");//打印,增强for循环for (Object obj : c) {System.out.println("增强for循环取值："+obj);}System.out.println("==============");//迭代器形式Iterator it = c.iterator();while (it.hasNext()){//判断有无下一个元素Object obj=it.next();//取值System.out.println("iterator取值："+obj);}}
}

Iterator：迭代器

hasNext(); 查看是否有下一个元素。有为true，无为false
next(); 取出下一个元素的值
remove(); 删除当前元素

在JAVA中，所有的对象都有toString方法；方便打印

通过添加一个对象到collection集合中

实体类

package com.zheng.demo1;public class Student {private int id;private String name;private String address;public Student() {}public Student(int id, String name, String address) {this.id = id;this.name = name;this.address = address;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}@Overridepublic String toString() {return "Student{" +"id=" + id +", name='" + name + '\'' +", address='" + address + '\'' +'}';}
}

加入到集合

package com.zheng.demo1;import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;public class MyCollection1 {public static void main(String[] args) {//创建容器Collection<Student> students = new ArrayList<Student>();//创建对象Student student1 = new Student(1, "小明", "北京");Student student2 = new Student(2, "小红", "河南");Student student3 = new Student(3, "小黑", "深圳");Student student4 = new Student(4, "小蓝", "上海");//添加对象到容器中students.add(student1);students.add(student2);students.add(student3);students.add(student4);//查看System.out.println(students.toString());System.out.println("=========增强for循环输出=========");//增强for循环输出for (Student student : students) {System.out.println(student.toString());}System.out.println("=========迭代器输出=========");//迭代器输出Iterator<Student> iterator = students.iterator();while (iterator.hasNext()) {System.out.println(iterator.next());}}
}

三、List集合

特点

有序，打印输出的顺序和添加时的顺序一致（不会帮你自动排序）
有下标，可以通过下标的形式访问对象
元素可以重复

方法

void add(int index,Object o) //在index位置插入元素
boolean addAll(int index,Collection c) //将一个集合中的元素添加到次集合中的index位置
Object get(int index) //返回集合中指定位置的元素
List subList(int fromIndex,int toIndex) //返回二者之间的元素

package com.zheng.demo1;import java.util.ArrayList;
import java.util.ListIterator;public class MyList2 {public static void main(String[] args) {ArrayList list = new ArrayList();list.add(2);list.add(3);list.add(1);list.add(5);list.add(2);list.add(4);System.out.println("通过下标访问：" + list.get(0));ListIterator listIterator = list.listIterator();while (listIterator.hasNext()) {System.out.println(listIterator.next());}}
}

listIterator：迭代器

hasNext(); 查看是否有下一个元素。有为true，无为false
next(); 取出下一个元素的值
hasPrevious();查看前一个元素是
previous();取出前一个元素
remove(); 删除当前元素

package com.zheng.demo1;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;public class MyList {public static void main(String[] args) {//创建一个list集合容器List list = new ArrayList();//添加数据list.add("1-小红");list.add("2-小黑");list.add("3-小青");list.add("4-小紫");System.out.println("当前集合大小" + list.size());//一般的遍历System.out.println("=========一般的遍历=======");for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}System.out.println("=========增强for循环遍历=======");//增强for循环遍历for (Object o : list) {System.out.println(o);}System.out.println("=========一般的迭代器遍历=======");//一般的迭代器遍历Iterator iterator = list.iterator();while (iterator.hasNext()) {System.out.println(iterator.next());}System.out.println("=========list迭代器从前到后遍历=======");//list特有的ListIterator listIterator = list.listIterator();while (listIterator.hasNext()) {String str = (String) listIterator.next();System.out.println(str);}System.out.println("=========list迭代器从后到前遍历=======");while (listIterator.hasPrevious()) {Object obj = listIterator.previous();System.out.println(obj);}}
}

List实现类

1、ArrayList【重点】

数据结构实现，查询快（数组是连续的存储地址）。增删慢（每增加或者删除都要移动大量的数据。末尾快一点）
jdk1.2版本。运行效率高，线程不安全

2、Vector:

数组结构，查询快，增删慢
jdk1.0版本，运行效率低，线程安全

3、LinkedList

链表结构实现，增删快（不连续的存储空间，只需要改变节点之间的指向）查询慢

package com.zheng.demo1;import java.util.LinkedList;
import java.util.ListIterator;public class MyLinkList {public void print(LinkedList<Student> students) {//迭代器遍历System.out.println("======迭代器遍历======");ListIterator<Student> studentListIterator = students.listIterator();while (studentListIterator.hasNext()) {Student student = studentListIterator.next();System.out.println(student);}}public static void main(String[] args) {MyLinkList myLinkList = new MyLinkList();//1、创建一个容器LinkedList<Student> students = new LinkedList<>();//2、创建对象Student student1 = new Student(1, "小黑", "周口");Student student2 = new Student(2, "小名", "沈丘");Student student3 = new Student(3, "小郑", "范营乡");Student student4 = new Student(4, "小芳", "666");//3、将对象加入集合students.add(student1);students.add(student2);students.add(student3);students.add(student4);//查看System.out.println(students.toString());//调用迭代器遍历myLinkList.print(students);//删除System.out.println("=====删除某个元素=====");students.remove(1);myLinkList.print(students);}
}

四、泛型
jdk1.5中引入的新特性。本质是参数化类型，把类型当做参数传递

泛型接口、泛型方法、泛型类
<T,…> T为占位符，表示一种引用类型
优点：（1）、提高代码的复用。（2）、防止类型转换异常，提高代码的安全性

1、泛型类

泛型变量
泛型作为传递的参数
泛型作为方法的返回值

注意：

泛型只能使用引用类型
不同泛型类型对象之间不能相互赋值

package com.zheng.demo2;//泛型类
public class MyGeneric<T> {T t;//1、泛型变量//2、泛型作为传递的参数public void show(T t) {System.out.println(t);}//3、泛型作为方法的返回值public T getT() {return t;}
}

package com.zheng.demo2;public class TestMyGeneric {public static void main(String[] args) {//使用泛型类创建对象MyGeneric<String> sm = new MyGeneric<>();sm.t = "你好";sm.show("呦呦呦");System.out.println(sm.getT());System.out.println("=============");MyGeneric<Integer> im = new MyGeneric<>();im.t = 999;im.show(666);System.out.println(im.getT());}
}

2、泛型接口

package com.zheng.demo2;public interface MyInterface<T> {T show(T t);
}

实现类

package com.zheng.demo2;public class MyInterfaceImpl1 implements MyInterface<Integer>{@Overridepublic Integer show(Integer integer) {return integer;}public static void main(String[] args) {MyInterfaceImpl1 impl1 = new MyInterfaceImpl1();System.out.println(impl1.show(999));}}

2、

package com.zheng.demo2;public class MyInterfacetImpl implements MyInterface<String>{public String show(String s) {return s;}public static void main(String[] args) {MyInterface omf = new MyInterfacetImpl();System.out.println(omf.show("hhhhhh"));}
}

3、

package com.zheng.demo2;public class MyInterfaceImpl2<T> implements MyInterface<T> {@Overridepublic T show(T t) {return t;}public static void main(String[] args) {MyInterfaceImpl2<String> impl2 = new MyInterfaceImpl2<>();System.out.println(impl2.show("daoajao"));System.out.println("============");MyInterfaceImpl2<Double> impl21 = new MyInterfaceImpl2<>();System.out.println(impl21.show(520.1313));}
}

3、泛型方法

package com.zheng.demo2;public class MyGenericMethod {//泛型方法public <T> T show(T t) {System.out.println("泛型方法" + t);return t;}public static void main(String[] args) {System.out.println(new MyGenericMethod().show(5));System.out.println("=============");System.out.println(new MyGenericMethod().show("哈哈哈哈"));}
}

四、set集合

无序、无下标、元素不可重复

1、hashSet【重点】

数组+链表+红黑树
基于hashcode计算元素存储位置
当哈希吗一样的时候，调用equals，如果为true,拒接存入

package com.zheng.demo3;import java.util.HashSet;
import java.util.Iterator;public class MySet {public static void main(String[] args) {//创建集合框架HashSet<String> set = new HashSet<>();//添加数据set.add("1-小红");set.add("2-小明");set.add("3-小白");set.add("4-小黑");set.add("5-小红");set.add("1-小红");//迭代器迭代集合元素 遍历Iterator<String> iterator = set.iterator();while (iterator.hasNext()) {System.out.println(iterator.next());}}
}

实体类

package com.zheng.demo3;public class School {private int id;private String name;public School() {}public School(int id, String name) {this.id = id;this.name = name;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "School{" +"id=" + id +", name='" + name + '\'' +'}';}
}

package com.zheng.demo3;import java.util.HashSet;
import java.util.Iterator;public class TestSet {public static void main(String[] args) {//1、创建集合容器HashSet<School> schools = new HashSet<>();//创建对象School school1 = new School(1, "清华大学");School school2 = new School(2, "北京大学");School school3 = new School(3, "浙江大学");//3、放入集合schools.add(school1);schools.add(school2);schools.add(school3);schools.add(new School(2,"北京大学"));//4、遍历Iterator<School> iterator = schools.iterator();while (iterator.hasNext()){School school=iterator.next();System.out.println(school);}}
}

2、TreeSet

存储结构：红黑树
要实现comparable接口，重写里边的方法，返回0代表元素重复
元素不重复
元素自动排序

package com.zheng.demo3;import java.util.Iterator;
import java.util.TreeSet;public class MyTree {public static void main(String[] args) {//1、创建一个集合TreeSet treeSet = new TreeSet();//2、加入元素treeSet.add(1);treeSet.add(3);treeSet.add(2);treeSet.add(4);treeSet.add(3);//3、迭代遍历Iterator iterator = treeSet.iterator();while (iterator.hasNext()) {int i = (int) iterator.next();System.out.println(i);}}
}

TreeSet案例：排列字符串的顺序

package com.zheng.demo3;import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;public class MyTreeSet {public static void main(String[] args) {//匿名内部类TreeSet<String> set = new TreeSet<>(new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {int n1 = o1.length() - o2.length();int n2 = o1.compareTo(o2);return n1 == 0 ? n2 : n1;}});set.add("he");set.add("hhhhh");set.add("jdjdjkdkk");set.add("djdj");Iterator<String> iterator = set.iterator();while (iterator.hasNext()) {System.out.println(iterator.next());}}
}

comparator：定制比较器

五、Map集合【重要】

特点：

用于存储任意键值对（k-v）
key不能重复，唯一。无序、无下标
value可以重复。无序、无下标

1、hashMap

存储结构：哈希表（数组+链表+红黑树）
方法：
put(k,v);存入
get(k);取值
containsKey();判断是否包含key
containsValue();判断是否包含value
entrySet();返回映射关系中包含的映射视图
keySet();返回映射关系中包含的键的映射视图

package com.zheng.demo4;import javax.lang.model.element.NestingKind;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class MyMap {public static void main(String[] args) {//1、创建集合Map<String, String> map = new HashMap<>();//2、塞入值map.put("A", "我是A");map.put("B", "我是B");map.put("C", "我是C");map.put("D", "我是D");//判断System.out.println(map.containsKey("A"));System.out.println(map.containsValue("我是C"));System.out.println("map集合大小：" + map.size());System.out.println("打印：" + map.toString());//遍历1、使用keysetSystem.out.println("=======使用keyset=======");Set<String> set = map.keySet();for (String s : set) {System.out.println(s + "=======" + map.get(s));}System.out.println("=======使用entryset=======");Set<Map.Entry<String, String>> entries = map.entrySet();for (Map.Entry<String, String> entry : entries) {System.out.println(entry.getKey() + "========" + entry.getValue());}//简化System.out.println("+===简化====+");for (Map.Entry<String, String> entry : map.entrySet()) {System.out.println(entry.getKey() + "========" + entry.getValue());}}
}

jdk1.8后当链表长度大于8，转化为红黑树存储
jdk1.8后，当链表长度小于6,转化为链表存储

map集合的实现类

HashMap
jdk1.2版本，线程不安全，运行快；允许null为key或者value
Hashtable
jdk1.0版本，线程安全，运行慢，不允许null为key或者value
properties
Hashtable的子类，使用String作为key或者value.通常用于配置文件的读取

六、Collections工具类

package com.zheng.demo5;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MyCollection {
public static void main(String[] args) {
List arrayList = new ArrayList();
arrayList.add(4);
arrayList.add(1);
arrayList.add(5);
arrayList.add(3);
arrayList.add(6);
arrayList.add(2);

    System.out.println(arrayList.toString());System.out.println("调用排序工具类");//调用工具类排序Collections.sort(arrayList);System.out.println(arrayList.toString());}

}

总结

集合的概念

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

List集合

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

set集合：

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

Map集合

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

Collections:

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