java集合框架学习总结

一、集合概念

• 概念：对象的容器，定义了对多个对象进行操作的常用方法（即实现了对对象常用的操作）。可实现数组的功能。
• 和数组区别：
  1>数组长度固定，集合长度不固定
  2>数组可以存储基本类型和引用类型，集合只能存储引用类型

1.Collection体系集合

2.Collection父接口

1>特点：代表一组任意类型的对象，无序，五下标，不能重复。
2>方法：
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210118193442270.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjM3MTgxMw==,size_16,color_FFFFFF,t_70)

• 案例演示

import java.util.*;

//Collection接口使用
//1>添加元素
//2>删除元素
//3>遍历元素
//4>判断
public class demo1 {
	public static void main(String[] srgs) {
		//创建集合
		Collection collection = new ArrayList();//父类引用指向子类对象，实现向上转型
		//1>添加元素
		collection.add("苹果");
		collection.add("香蕉");
		collection.add("西瓜");
		collection.add("西瓜");
		System.out.println("元素个数："+collection.size());
		System.out.println(collection);//相当于调用collection.toString();
		
		//2>删除元素
		collection.remove("香蕉");
		System.out.println("元素个数："+collection.size());
		
		//3>遍历元素
		//遍历的第一种方式使用增强for
		for(Object object : collection) {
			System.out.println(object);
		}
		//遍历的第二种方式，使用迭代器
		Iterator it = collection.iterator();
		//Iterator迭代器共有3个方法：hasNext()[判断是否还有下一个元素]和next()[获取下一个元素]和remove()[删除当前元素]
		while(it.hasNext()) {
			String s = (String)it.next();//因为next的返回类型是Object类型，所以这一步是进行强制转化
			System.out.println(s);
		}
		//4>判断
		//判断是否含含某一个元素
		System.out.println(collection.contains("苹果"));
	}
}

• 运行结果：
  

3.List子接口

1>特点：有序、有下标、元素可以重复
2>方法：
3>案例演示

import java.awt.List;
import java.util.*;

public class dem02 {
	public static void main(String args[]) {
		//创建集合对象
		ArrayList list=new ArrayList<>();
		//1.添加元素
		list.add("小米");
		list.add("苹果");
		list.add(0,"华为");
		System.out.println("元素个数"+list.size());
		System.out.println(list.toString());
		//2.遍历元素
		//增强for
		for(Object object : list) {
			System.out.println(object);
		}
		//迭代器
		Iterator it = list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//使用for,因为有角标
		for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));//使用角标打印
		}
		//3.判断
		System.out.println(list.contains("华为"));
		System.out.println(list.isEmpty());//这是判断是否为空
		
	}
}

结果截图

4>List实现类
ArrayList类（数组结构实现，查询快，增删慢）
Vector类（数组结构实现，查询快，增删慢）
LinkedList类（链表结构实现，查询慢，增删快）

演示Vector集合的使用

import java.util.Vector;

public class dem03 {
	public static void main(String[] args) {
		//创建集合
		Vector vector = new Vector<>();
		//1.添加元素
		vector.add("苹果");
		vector.add("香蕉");
		vector.add("黄梨");
		vector.add("西红柿");
		System.out.println("元素个数:"+vector.size());
		//2.删除
		vector.remove(0);
		vector.remove("苹果");
		System.out.println("元素个数:"+vector.size());
		//3.遍历
		for(int i=0;i<vector.size();i++) {
			System.out.println(vector.get(i));
		}
		
	}
}

结果截图如下

演示LinkedList

import java.util.LinkedList;

//LinkedList的使用

public class demo04 {
	public static void main(String[] args) {
		//1.创建LinkedList类的实例
		LinkedList linkedlist = new LinkedList<>();
		//2.添加元素
		linkedlist.add("我是");
		linkedlist.add("中国人");
		linkedlist.add("我爱");
		linkedlist.add("我的");
		linkedlist.add("祖国");
		//3.遍历
		//使用for遍历
		for(int i=0;i<linkedlist.size();i++) {
			System.out.println(linkedlist.get(i));
		}
	}
}

效果截图

ArrayList与LinkedList区别
1>从元素存储的结构上区分
ArrayList开辟的是连续的空间
LinkedList开辟的是节点
如下图

二、泛型

二-一、基本知识

1.什么是泛型？

答：泛型其本质是参数化类型，把类型作为参数传递。

2.常见形式有哪些？

答：泛型类，泛型方法，泛型接口。

3.语法是怎么样的呢？

答：<T,……>T称为一种类型占位符，是一种引用类型。

4.使用泛型的好处？

答：
1>提高代码的重用性。
2>防止类型转换异常，提高代码的安全性。

二-二、案例演示（泛型类、泛型方法、泛型接口)

1.泛型类

//myGen.java创建myGen<T>泛型类
/*
 * 泛型类
 * 语法：类名<T,……>
 * T是类型占位符，表示一种引用类型，如果使用多个使用逗号隔开
 * 注意：
 * 1.泛型只能使用引用类型
 * 2.不同的泛型对象之间不能相互赋值
**/
public class myGen<T> {
	//使用泛型T
	//1.创建变量
	T t;
	//2.泛型作为方法的参数
	public void show(T t) {
		//T t = new T();注意：这是一个错误写法，因为T表示一种泛型，我们不知道T的构造函数，也不知道T是否是final修饰，因此只能创建变量，不能实例化		
		System.out.println(t);
	}
	//3.泛型作为方法的返回值
	public T getT(T t) {
		return t;
	}
	            
}

//testGen.java使用泛型类
public class testGen {
	public static void main(String[] args) {
		//使用泛型类创建对象
		myGen<String> mygen = new myGen<String>();
		String s=mygen.t="加油、坚持";
		mygen.show(s);
		String str = mygen.getT(s);
		mygen.show(str+"第二次");
		
		//使用Integer类型
		myGen<Integer> mygen2 = new myGen<>();
		int i=mygen2.t=520;
		System.out.println(i);
		
	} 
}

结果截图：

2.泛型接口

//myInterface.java声明一个接口
/*
 * 泛型接口
 * 语法：接口名<T>
 * 注意：不能使用泛型来创建静态常量
 * 
 * */

public interface myInterface<T> {
	String str="祖国花朵";
	T server(T t);
}
//myInterfaceimpl.java接口的实现类
public class myInterfaceimpl implements myInterface<String>{
	public String server(String t) {
		System.out.println(t);
		return t;
	}
	public static void main(String[] args) {
		myInterfaceimpl impl = new myInterfaceimpl();
		impl.server("abcd");
		
	}
}
//myInterfaceimpl2.java实现的第二种写法
//实现接口的泛型类的第二种写法：不指定类型

public class myInterfaceimpl2<T> implements myInterface<T> {

	@Override
	public T server(T t) {
		// TODO Auto-generated method stub
		System.out.println(t);
		return t;
	}
	public static void main(String[] args) {
		myInterfaceimpl2<Integer> impl2 = new myInterfaceimpl2<>();
		impl2.server(520);
	}
}

结果截图：

3.泛型方法

//mygenMe.java
/*
 * 泛型方法
 * 语法：<T>返回值类型
 *注意调用方法时，类型由传入的数据决定。如传入字符串型数据，则类型即为字符串
 *
 * */
public class mygenMe {
	//泛型方法的创建
	public <T> void show(T t) {
		System.out.println(t);
	}
	public static void main(String[] args) {
		mygenMe meth = new mygenMe();
		meth.show("中国加油");//此时就是字符串类型String
		meth.show(123);//此时就是整型int
		meth.show(123.4);//此时就是double类型
	}
}

效果截图

二-三、泛型集合

1.概念

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

2.特点

编译时即可检查，而非运行时抛出异常
访问时，不必类型转换（装箱）
不同泛型之间引用不能相互赋值，泛型不存在多态

3.Set集合

3.1.Set子接口

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

3.2.Set实现类

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

案例演示

import java.util.HashSet;
import java.util.Set;

/*
 * 测试Set接口的使用
 * 特点：无序（即打印元素出来的顺序与添加元素的顺序无关）、没有下标、不能重复
 * */
public class setdemo1 {
	public static void main(String[] args) {
		//1.创建集合
		Set<String> s = new HashSet<>();
		//2.添加数据
		s.add("苹果");
		s.add("小米");
		s.add("华为");
		s.add("三星");
		System.out.println(s.size());
		System.out.println(s.toString());
		//3.遍历
		//使用增强for遍历
		for(Object object : s) {
			System.out.println(object);
		}
		//4.判断
		System.out.println(s.contains("华为"));
		System.out.println(s.isEmpty());
	}
}

3.3.hashSet类简单使用

import java.util.*;
/*
 * HashSet集合的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 * 
 * */
public class hashsetdemo1 {
	public static void main(String[] args) {
		//新建集合
		HashSet<String> hashSet=new HashSet<String>();
		//1.添加元素
		hashSet.add("张三");
		hashSet.add("李四");
		hashSet.add("王五");
		hashSet.add("赵六");
		System.out.println("元素个数："+hashSet.size());
		System.out.println(hashSet.toString());
		//2.删除元素
		hashSet.remove("张三");
		System.out.println(hashSet.toString());
		//3.遍历
		//使用增强for
		for(String str : hashSet) {
			System.out.println(str);
		}
		//使用迭代器
		Iterator<String> it=hashSet.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//4.判断
		System.out.println(hashSet.contains("李四"));
		System.out.println(hashSet.isEmpty());
	}
}

效果截图如下

3.4.TreeSet

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

//TreeSetdemo1.java
import java.util.*;

public class TreeSetdemo1 {
	public static void main(String[] args) {
		//1.创建集合
		TreeSet<String> tree = new TreeSet<>();
		//2.添加元素
		tree.add("abc");
		tree.add("xyz");
		tree.add("def");
		System.out.println("元素个数："+tree.size());
		System.out.println(tree.toString());//[abc, def, xyz]自动排序
		//3.遍历
		//使用增强for
		for(String str : tree) {
			System.out.println(str);
		}
		//使用迭代器
		Iterator it =  tree.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//4.判断
		System.out.println(tree.contains("abc"));
		
	}
}
//TreeSetdemo1.java打印结果：
//元素个数：3
//[abc, def, xyz]
//abc
//def
//xyz
//abc
//def
//xyz
//true

//TreeSetdemo2.java
import java.util.*;

public class TreeSetdemo2 {
	public static void main(String[] args) {
		// 1.创建集合
		TreeSet<Person> tree2 = new TreeSet<>();
		// 2.添加元素
		Person p1 = new Person("张三", 20);
		Person p2 = new Person("李四", 18);
		Person p3 = new Person("王五", 21);
		Person p4 = new Person("兆龙", 19);
		tree2.add(p1);
		tree2.add(p2);
		tree2.add(p3);
		tree2.add(p4);

		System.out.println("元素个数：" + tree2.size());
		// 3.遍历
		// 使用增强for
		for (Person str : tree2) {
			System.out.println(str.toString());
		}
		// 使用迭代器
		Iterator<Person> it = tree2.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		
	}

}

class Person implements Comparable<Person> {// 实现 Comparable接口，以便于重写ComparaTo方法，从而定义新的排序规则
	private int age;
	private String name;

	Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;

	}

	public int getAge() {
		return age;

	}

	public void setName(String s) {
		name = s;

	}

	public void setAge(int a) {
		age = a;
	}
	
	public String toString() {
		return "["+name+","+age+"]";
	}
	@Override
	public int compareTo(Person o) {// 定义新的排序规则
		// TODO Auto-generated method stub
		int n1 = this.getAge() - o.getAge();
		int n2 = this.getName().compareTo(o.getName());

		return n1 == 0 ? n1 : n2;// 先按年龄比较
	}
}

//TreeSetdemo2.java打印结果：
//元素个数：4
//[兆龙,19]
//[张三,20]
//[李四,18]
//[王五,21]
//[兆龙,19]
//[张三,20]
//[李四,18]
//[王五,21]

//使用TreeSet集合实现字符串按长度进行排序(输出时，字符串长度小的在前，字符串长度较大的在后面)案例
//
import java.util.Comparator;
import java.util.TreeSet;

public class Treeset_string_sort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 1.创建集合
		TreeSet<String> tree3 = new TreeSet<>(new Comparator<String>() {// 使用匿名内部类的形式实现Comparator接口

			@Override
			public int compare(String o1, String o2) {// 重写比较规则
				// TODO Auto-generated method stub
				int n = o1.length() - o2.length();
				int n2 = o1.compareTo(o2);// 如果字符串长度一样，则按此原来规则进行
				return n == 0 ? n2 : n;
			}

		});
		// 2.添加数据
		tree3.add("wwwdwwdw");
		tree3.add("sss");
		tree3.add("aaa");
		tree3.add("wwddd");
		tree3.add("wewewee");
		System.out.println(tree3.size());
		System.out.println(tree3.toString());
	}

}
//打印结果：
//5
//[aaa, sss, wwddd, wewewee, wwwdwwdw]

4.Map集合

Map接口的特点：
用于存储任意键值对（key-Value）
其中：键，是无序、无下标、不允许重复（唯一）；
值，是无序、无下标、允许重复。
Map接口的实现类：HashMap
Map接口的子接口：SortedMap；
该子接口的实现类：TreeMap
常用方法：

4.1.Map接口的使用

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*
 * Map接口使用：
 * 特点：无序、无下标、键唯一（不重复）、值可以重复
 * 
 * */
public class map_user1 {
	public static void main(String[] args) {
		//1.创建Map集合
		Map<String,String> map = new HashMap<>();
		//2.添加元素
		map.put("cn", "中国");
		map.put("uk","英国");
		map.put("us","美国");
		System.out.println("元素个数："+map.size());
		System.out.println(map.toString());
		//3.删除
		map.remove("cn");//以键的方式删除元素；因为键是唯一的
		System.out.println("删除之后的元素个数："+map.size());
		//4.遍历
		//先调用keySet()方法，将转化为所有键的set集合
		Set<String> keyset = map.keySet();
		//4-1使用增强for
		for(String str : keyset) {
			System.out.println(str+"------------>"+map.get(str));//get()方法，通过key获取value			
		}
		//4-2.使用entrySet()方法实现遍历
		Set<Map.Entry<String,String>> entryset=map.entrySet();//把<>里的整体Map.Entry<String,String>看作一个集合理解即可
		//就是把拿过来的Set集合的数据封装成一个个的Map.Entry键值对类型。而此时我们就要根据getKey()和getValue()方法将其获取相应的值
		
		//使用增强for，注意此时的类型是Map.Entry<String,String>
		for(Map.Entry<String,String> trys : entryset) {//Entry就是一个映射对（或者说是键值对）。
			System.out.println(trys.getKey()+"-----"+trys.getValue());
		}
		//5.判断
		System.out.println(map.containsKey("us"));//判断其键中是否含有us
		System.out.println(map.containsValue("美国"));//判断其值中是否含有“美国”
	}
}

程序运行结果

图解上述两种遍历方式：

4.2.HashMap实现类的使用

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

import java.util.HashMap;
import java.util.Map;

public class Hashmap_user {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//1.创建集合
		HashMap<Student,String> hashmap = new HashMap<Student,String>();
		//2.添加元素
		Student s1 = new Student("张三",101);
		Student s2 = new Student("王五",102);
		Student s3 = new Student("赵四",103);
		Student s4 = new Student("李四",104);
		hashmap.put(s1,"一等奖");
		hashmap.put(s2,"二等奖");
		hashmap.put(s3,"三等奖");
		hashmap.put(s4,"优秀奖");
		System.out.println("元素个数："+hashmap.size());
		System.out.println(hashmap.toString());
		//3.删除元素
		hashmap.remove(s1);
		System.out.println("删除后的元素个数："+hashmap.size());
		//4.遍历
		//使用keySet()方法转化为set集合;get()方法就是根据键获取值cu
		for(Student str : hashmap.keySet()) {
			System.out.println(str.toString()+"----"+hashmap.get(str));
		}
		//使用entrySet()方法遍历,将其转化为Map.Entry<Student, String>类型的键值对
		for(Map.Entry<Student, String> entry : hashmap.entrySet()) {
			System.out.println(entry.getKey()+"---"+entry.getValue()+"第2种");
		}
		//5.判断
		System.out.println(hashmap.containsKey(s1));
		System.out.println(hashmap.containsValue("三等奖"));
	}
		
}
class Student{
	private String str;
	private int num;
	Student(String s,int n){
		str=s;
		num=n;
	}
	void setStr(String s) {
		str=s;
	}
	void setNum(int n) {
		num=n;
	}
	String getStr() {
		return str;
	}
	int getNum() {
		return num;
	}
	public String toString() {
		return str+"  "+num;	
	}
}

程序运行结果截图：

4.3.TreeMap集合

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

import java.util.Map;
import java.util.TreeMap;

public class treemap_user {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//1.创建集合
		TreeMap<Stu,String> treemap = new TreeMap<Stu,String>();
		//2.添加元素
		Stu t1 = new Stu("张三",101);
		Stu t2 = new Stu("王五",102);
		Stu t3 = new Stu("赵四",103);
		Stu t4 = new Stu("李四",104);
		treemap.put(t1,"一等奖");
		treemap.put(t2,"二等奖");
		treemap.put(t3,"三等奖");
		treemap.put(t4,"优秀奖");
		System.out.println("元素个数："+treemap.size());
		System.out.println(treemap.toString());
		//3.删除元素
		treemap.remove(t1);
		System.out.println("删除后的元素个数："+treemap.size());
		//4.遍历
		//使用keySet()方法转化为set集合;get()方法就是根据键获取值
		for(Stu str : treemap.keySet()) {
			System.out.println(str.toString()+"----"+treemap.get(str));
		}
		//使用entrySet()方法遍历,将其转化为Map.Entry<Stu, String>类型的键值对
		for(Map.Entry<Stu, String> entry : treemap.entrySet()) {
			System.out.println(entry.getKey()+"---"+entry.getValue()+"第2种");
		}
		//5.判断
		System.out.println(treemap.containsKey(t1));
		System.out.println(treemap.containsValue("三等奖"));
	}
		
}
class Stu implements Comparable<Stu>{
	private String str;
	private int num;
	Stu(String s,int n){
		str=s;
		num=n;
	}
	void setStr(String s) {
		str=s;
	}
	void setNum(int n) {
		num=n;
	}
	String getStr() {
		return str;
	}
	int getNum() {
		return num;
	}
	public String toString() {
		return str+"  "+num;	
	}
	@Override
	public int compareTo(Stu o) {
		// TODO Auto-generated method stub
		//比学生学号,如果没有这个吧将会报错java.lang.ClassCastException:
		int n1 = this.num-o.getNum();
		return n1;
	}
}

程序运行结果截图

5.Colletions工具类

集合工具类，定义了除了存取以外的集合常用方法（对集合的操作）
常用方法：

import java.util.*;

public class collections_user {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(20);
		list.add(2);
		list.add(10);
		list.add(15);
		list.add(30);
		//sort排序
		System.out.println("排序之前："+list.toString());
		Collections.sort(list);
		System.out.println("排序之后："+list.toString());//[2, 10, 15, 20, 30]
		//binarySearch二分查找
		int i =Collections.binarySearch(list, 10);//找不到返回任意的负数，找得到就返回该值所在的下标值
		System.out.println(i);
		//copy复制
		//注意：要目标集合的大小与所在源集合的大小相同时才能被复制成功
		ArrayList<Integer> dest = new ArrayList<Integer>();//没有添加元素时，改集合大小是0
//		System.out.println(dest.size());//0
		for(int j = 0;j<list.size();j++) {
			//这一步使得该集合的元素大小等于源集合的元素的大小
			dest.add(j);
		}
		Collections.copy(dest, list);//第一个参数为目标集合。第二个参数为源集合
		System.out.println(dest.toString());
		//reverse反转
		Collections.reverse(list);
		System.out.println("反转之后："+list.toString());//[30, 20, 15, 10, 2]
		//shuffle打乱
		Collections.shuffle(list);
		System.out.println("打乱之后："+list.toString());//打乱之后：[10, 30, 20, 15, 2]
		//补充：list转化为数组
		Integer[] arr=list.toArray(new Integer[0]);//使用<Integer> Integer[] java.util.ArrayList.toArray(Integer[] a)
		System.out.println(arr.length);
		System.out.println(Arrays.toString(arr));//[15, 10, 20, 2, 30]和打乱之后的顺序一样
		//数组转化成集合
		String[] str1 = {"张三","李四","王五","zhaoliu"};
		List<String> list2 = Arrays.asList(str1);//注意此时这个集合是一个受限集合，不能添加和删除元素，因为数组的长度是固定的，相当于此时集合的长度已经固定
		
		System.out.println(list2);
		//再注意，把基本类型转化为数组时，需要把他的类型改变为包装类
		Integer[] in = {20,1,10,3,60,56};//注意此时的Integer不能转变为int
		List<Integer> inlist = Arrays.asList(in);
		System.out.println(inlist);//[20, 1, 10, 3, 60, 56]
	}
}

程序运行结果截图：

6.集合总结

集合的概念：
对象的容器，和数组类似，定义了对多个对象进行操作的常用方法。
List集合：有序、元素可以重复、有下标。（ArrayList、LinkedList、Vector）。
Set集合：无序、无下标、元素不可重复（HashSet、TreeSet）。
Map集合：存储一对数据，无序、无下标、键不可重复，值可重复。（HashMap、HashTable、TreeMap）
collections:集合工具类，定义了除了存取以外的集合常用方法