[Java知识库] 四、Java中的常用API(通过包进行分类)

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> 四、Java中的常用API(通过包进行分类) -> 正文阅读

[Java知识库]四、Java中的常用API(通过包进行分类)

一、java.lang包下的类

1.Object类：只有无参构造器，没有有参构造器

??⑴地位：
???①Java中唯一一个没有父类的类
???②只要是Java中的类，不是Object的直接子类，就是Object的间接子类
???③在Java中如果没有明确指出继承哪个类，则自动继承Object类
??⑵常用方法：
???①构造器:只有无参构造器
???② boolean equals(Object obj) ：
?????判断内存地址是否相同，等效于"=="
?????如果是子类对equals方法进行了重写时，则比较的是引用数据类型值是否相同。

常考题：
???简述equals和"=="的异同？
???? == ：如果操作的是基本的数据类型，则比较的值是否相等
????? ? 如果比较的引用数据类型则比较的引用数据的内存地址是否相等
???? equals: 如果是Object类中的equals方法，则比较的是引用数据类型的内存地址是否相等，等效于 ==
???? ?? 如果是Object的子类对equals方法进行了重写，则比较的是引用数据类型的值是否相等。

2.System类：被final修饰(不能被继承)，不能实例化(所有类成员都被static修饰)

??⑴类成员：
???①成员属性：
????System.in
????System.out
???①成员方法：
????static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

3.Math类：被final修饰(不能被继承)，封装了所有操作低等数学的方法

??⑴类成员：
???①成员属性：
????Math.PI----------------生活中的Π
???①成员方法：(数学中常用公式基本上都可以找到)
????static double random() 生成一个随机数，返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。（最常用）
????static Object abs(Object obj) 返回各种基本数据类中数值型的绝对值。
????static Object max(Object a, Object b) 返回两个基本数据类中数值型的其中较大的一个。
????。。。。

4.包装类：

??⑴为什么使用包装类：
???由于Java是一门完全面向对象编程语言，我们需要通过对象名.方法更直接快捷地解决问题，但是基本数据类型没有办法直接通过对象名打点的方式调用，因此Java提供了包装类供我们使用。
??⑵包装的是什么?
???Java中所有的基本数据类型
??⑶包装类的格式：
在这里插入图片描述
??⑷Integer中常量池的概念：

 public static void main(String[] args) {
        Integer a  = new Integer(127);
        Integer b  = new Integer(127);
        System.out.println(a==b);
        System.out.println(a.equals(b));
        Integer c=128;
        Integer d=128;
        System.out.println(c==d);
         Integer e=127;
         Integer f=127;
        System.out.println(e==f);
    }

上述代码在内存中的实际情况：
在这里插入图片描述

a.当Integer类型的数值在[-128,128)时：如果两个new出来Integer对象，即使值相同，通过 “== ”比较结果为false，但两个对象直接赋值，则通过 “== ”比较结果为“true，这一点与String非常相似。
b.当数值不在-128~127时，无论通过哪种方式，即使两个对象的值相等，通过 “== ”比较，其结果为false；
c.当一个Integer对象直接与一个int基本数据类型通过“==”比较，其结果与第一点相同；（自动装箱和自动拆箱）

??⑸String类型、基本数据类型和包装类之间的转换
???以Integer为例：
在这里插入图片描述
??⑹自动拆/装箱：在jdk1.5以后出现的
????装箱：基本数据类型转包装类
????拆箱：包装类转基本数据类型

int a = 5;
Integer b = a;//自动装箱
int c = b;//自动拆箱

5.String/StringBuffer/StringBuilder类：

String在内存中的区别：https://www.cnblogs.com/long-holiday/p/10246161.html

String类
⑴作用：
用来存放多个字符,值一定放在" "里面。
⑵通过构造方法创建的字符串对象和直接赋值方式创建的字符串对象有什么区别呢?
通过构造方法创建的字符串对象是在堆内存。通过赋值创建的字符串对象是在方法区的常量池

public class TestDemo {
    public static void main(String[] args) {
        String s1=new String("hello");//通过构造方法创建字符串对象
        String s2="hello";//直接赋值创建的字符串对象
        System.out.println("s1:"+s1);
        System.out.println("s2:"+s2);
        //比较的是2个对象的地址
        System.out.println("s1==s2:"+(s1==s2));//false

        String s3="hello";
        System.out.println("s1==s3:"+(s1==s3));//false
        System.out.println("s2==s3:"+(s2==s3));//true
    }
}

在这里插入图片描述
⑶特点
?①被final修饰，不能被继承
?②一旦赋值，长度固定
?③String、StirngBuffer、StringBuilder三者之间没有继承关系，但是有操作相同数据类型的关系(即操作字符串)
⑷常用方法：
?①构造器：
?a、String() 初始化一个新创建的 String 对象，使其表示一个空字符序列。
?b、String(byte[] bytes, int offset, int length) :将指定的字节数组bytes从offset开始，转换成长度为length的字符串
?c、String(byte[] bytes) 将字节数组转换成String类型的字符串
?d、public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
?e、public String(char[] value,int beginIndex,int length) ：将指定的字符数组value从beginIndex开始，转成成字符串，转换的长度时length长度
?②用于比较的方法：
?a、public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。判断二者的值是否相等。
?b、public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，判断是否相等，忽略大小写。
?c、int compareTo(String anotherString) 按字典顺序比较两个字符串。（调用对象减参数对象，严格区分大小写）

①当两个字符串的长度和值都相等时候，返回值为0
②当长度一致，但值不一致时侯，返回第一次出现不同字母的ASCII值的差
③当长度不一致时
?值部分一致，返回长度的差(如：String = “abc”；String = “abcdef”；)
?值也不一致，返回第一次出现不同字母的ASCII的差值（String = “abc”；String =“def”；）

?d、int compareToIgnoreCase(String str) 功能同int compareTo(String anotherString) ，不考虑大小写。

?③获取功能的方法：
?a、public int length () ：返回此字符串的长度。
?b、public String concat (String str) ：将指定的字符串连接到该字符串的末，并将其返回。
?c、public char charAt (int index) ：返回指定索引处的 char值。
?d、public int indexOf (int ch) ：返回指定子字符串第一次出现在该字符串内的索引。(其中的字符既可以时char类型，也可以是其对应的ASSII码)
?e、 int lastIndexOf(int ch, int fromIndex)返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索（即从左向右搜索）。
?f、int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。
?g、int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索（即从左向右搜索）。
?h、public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
?i、public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
?④转换功能的方法
?a、public char[] toCharArray () ：将此字符串转换为新的字符数组。
?b、public byte[] getBytes () :将指定的字符串转换成字节数组
?c、public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。
? d、String toUpperCase() 将指定的String 中的所有字符都转换为大写。
?e、String toLowerCase()将指定的String 中的所有字符都转换为小写。
? f、String trim() 将指定的字符串去掉首位空格后返回
?⑤分割功能的方法
?public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。
?⑥用于判断的方法
?a、boolean isEmpty()当且仅当 length() 为 0 时返回 true。
?b、boolean endsWith(String suffix)判断此字符串是否以指定的后缀结束。
?c、 boolean startsWith(String prefix)判断此字符串是否以指定的前缀开始。
?d、 boolean startsWith(String prefix, int toffset) 判断此字符串从指定索引开始的子字符串是否以指定前缀开始。
?e、boolean contains(CharSequence s) 当且仅当此字符串包含指定的 char 值序列时，返回 true（即判断String是否包含指定的字符）。

StringBuffer(多线程更安全，并且其没有重写equals方法和hashcode方法，equals比较的依旧是地址)
⑴为什么使用StringBuffer？
为了解决创建String对象时不能随意更改String长度的问题，java提供了一个缓存技术(即Buffer)，并将这种技术应用到类的创建中，因此出现StringBuffer类，简单可以理解为StringBuffer是一种可变的字符串(即长度可变)
⑵常用方法
?①构造方法：
?a、StringBuffer() ：构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。
?b、StringBuffer(String str) 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
?①普通常用方法：
?a、 StringBuffer append(Object obj)：将参数追加到指定字符串尾部后返回
?b、 StringBuffer insert(int index, Object obj) ：将参数插入到指定索引位置并返回
?c、 StringBuffer delete(int beginIndex, int endIndex) ：将[beginIndex, endIndex) 范围之间的字符删除后返回（删除一串）
?d、StringBuffer deleteCharAt(int index) ：删除指定位置的字符并返回(删除一个)
?e、 void setCharAt(int index, char ch) 用ch修改指定位置上的字符
?f、 StringBuffer replace(int start, int end, String str) 用str替换指定范围[int start, int end）之间的字符串
?g、int capacity() ：获取调用对象的容量并返回

注意：在StringBuffer类中所有与String’类方法名相同的方法用法也一致。
StringBuilder(单线程，更安全)
⑴常用方法：
?a、StringBuilder() 构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。
?b、StringBuilder(int capacity) 构造一个其中不带字符的字符串生成器，初始容量由 capacity 参数指定。
?c、StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。

注意：在StringBuilder类中所有与String’类、StringBuffer类方法名相同的方法用法也一致。

6.String/StringBuffer/StringBuilder类之间的比较：

在这里插入图片描述

7.正则表达式：

⑴含义：
用来规划接收到字符串类型的数据格式
⑵分类：
?①前台：js
?②后台：java
⑶格式
?^--------------------------------起始符合
?$--------------------------------结束符号

注意：在后台，这两个符号可以省略不写，但在js中必须写，因此建议在后台使用正则表达式时，也写上。

?[]---------------------------------一个占位符：如果该位置上只有一种可能，该符号可以省略。
?|-----------------------------------或者：当一个位置上有多种可能时，该符号可以省略
?()------------------------------组合：至少两个以上字连续使用，在()中的|不能省略
?{}----------------------------------范围：
???????????????①{n}-----------恰好出现n次
???????????????②{n,}-----------至少出现n次
?{n,m}至少出现n次，至多出现m次，范围为[n,m]
?\d-------------------全部为数字（与[0-9],(0|1|2|3|4|5|6|7|8|9)一个意思）
?\w-----------------任何一个字母数字字符（大小写均可）或下划线,等价于 [A-Za-z0-9_]
?. -------------------表示任意字符（除换行符以外）
?+ ------------------至少出现一次，等效于{1,}
?\u4e00 —— \u9fa5 ---------------- 中文汉字
⑷常用方法——————封装在String类中
?boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。
? String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串,并以字符串数组的形式返回

二、java.util 包下的类

1.集合框架

⑴集合的作用：存储任意引用数据类型的容器
⑵集合和数组既然都是容器，它们有啥区别呢？
?①数组的长度是固定的。集合的长度是可变的。
?②数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。
⑶分类
在这里插入图片描述

集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map

⑷Collection 通用方法
Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：

public boolean add(E e)：把给定的对象添加到当前集合中。
public void clear() :清空集合中所有的元素。
public boolean remove(E e): 把给定的对象在当前集合中删除。
public boolean contains(E e): 判断当前集合中是否包含给定的对象。
public boolean isEmpty(): 判断当前集合是否为空。
public int size(): 返回集合中元素的个数。

public Object[] toArray(): 把集合中的元素，存储到数组中。

例如：
import java.util.ArrayList;
import java.util.Collection;

public class Demo1Collection {
    public static void main(String[] args) {
		// 创建集合对象 
    	// 使用多态形式
    	Collection<String> coll = new ArrayList<String>();
    	// 使用方法
    	// 添加功能  boolean  add(String s)
    	coll.add("小李广");
    	coll.add("扫地僧");
    	coll.add("石破天");
    	System.out.println(coll);

    	// boolean contains(E e) 判断o是否在集合中存在
    	System.out.println("判断  扫地僧 是否在集合中"+coll.contains("扫地僧"));

    	//boolean remove(E e) 删除在集合中的o元素
    	System.out.println("删除石破天："+coll.remove("石破天"));
    	System.out.println("操作之后集合中元素:"+coll);
    	
    	// size() 集合中有几个元素
		System.out.println("集合中有"+coll.size()+"个元素");

		// Object[] toArray()转换成一个Object数组
    	Object[] objects = coll.toArray();
    	// 遍历数组
    	for (int i = 0; i < objects.length; i++) {
			System.out.println(objects[i]);
		}

		// void  clear() 清空集合
		coll.clear();
		System.out.println("集合中内容为："+coll);
		// boolean  isEmpty()  判断是否为空
		System.out.println(coll.isEmpty());  	
	}
}

⑸迭代器
在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。
①Iterator接口的常用方法如下：

public E next():返回迭代的下一个元素。

public boolean hasNext():如果仍有元素可以迭代，则返回 true。

public class IteratorDemo {
  	public static void main(String[] args) {
        // 使用多态方式 创建对象
        Collection<String> coll = new ArrayList<String>();

        // 添加元素到集合
        coll.add("串串星人");
        coll.add("吐槽星人");
        coll.add("汪星人");
        //遍历
        //使用迭代器 遍历   每个集合对象都有自己的迭代器
        Iterator<String> it = coll.iterator();
        //  泛型指的是 迭代出 元素的数据类型
        while(it.hasNext()){ //判断是否有迭代元素
            String s = it.next();//获取迭代出的元素
            System.out.println(s);
        }
  	}
}

②Iterator迭代器的实现原理
当遍历集合时，首先通过调用集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。
在这里插入图片描述

在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。

⑹增强for
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
①格式：

for(元素的数据类型  变量 : Collection集合or数组){ 
  	//写操作代码
}

它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

⑺泛型
①使用泛型的原因分析：
在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

public class GenericDemo {
	public static void main(String[] args) {
		Collection coll = new ArrayList();
		coll.add("abc");
		coll.add("itcast");
		coll.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放
		Iterator it = coll.iterator();
		while(it.hasNext()){
			//需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
			String str = (String) it.next();
			System.out.println(str.length());
		}
	}
}
//程序在运行时发生了问题**java.lang.ClassCastException**。

为什么会发生类型转换异常呢？
我们来分析下：由于集合中什么类型的元素都可以存储。导致取出时强转引发运行时ClassCastException。
怎么来解决这个问题呢？
Collection虽然可以存储各种对象，但实际上通常Collection只存储同一类型对象。例如都是存储字符串对象。因此在JDK1.5之后，新增了泛型(Generic)语法，让你在设计API时可以指定类或方法支持泛型，这样我们使用API的时候也变得更为简洁，并得到了编译时期的语法检查。
泛型：

可以在类或方法中预支地使用未知的类型。一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

②使用泛型的好处

将运行时期的ClassCastException，转移到了编译时期变成了编译失败。

避免了类型强转的麻烦。

public class Test {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("kejizhentan");
        // list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
        // 集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            //当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
            System.out.println(str.length());
        }
    }
}

注意:泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型。

③泛型的定义

定义格式：

修饰符 class 类名<代表泛型的变量> {  }

例如，API中的ArrayList集合：
class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

④泛型的使用场景：
?? 泛型用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

什么时候确定泛型？
??在创建对象的时候确定泛型
例如，ArrayList<String> list = new ArrayList<String>();
此时，变量E的值就是String类型,那么我们的类型就可以理解为：
class ArrayList<String>{
? public boolean add(String e){
? }
?public String get(int index){
? }
? …
}

含有泛型的类
定义格式：

修饰符 class 类名<代表泛型的变量> {  }

以自定义泛型为例：

步骤一：定义含有泛型的类
	public class MyGenericClass<MVP> {
		//没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
		private MVP mvp;
	     
	    public void setMVP(MVP mvp) {
	        this.mvp = mvp;
	    }
	     
	    public MVP getMVP() {
	        return mvp;
	    }
	}
步骤二：使用含有泛型的类
	public class GenericClassDemo {
  	public static void main(String[] args) {		 
         // 创建一个泛型为String的类
         MyGenericClass<String> my = new MyGenericClass<String>();    	
         // 调用setMVP
         my.setMVP("大胡子登登");
         // 调用getMVP
         String mvp = my.getMVP();
         System.out.println(mvp);
         //创建一个泛型为Integer的类
         MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); 
         my2.setMVP(123);   	  
         Integer mvp2 = my2.getMVP();
    }
}

确定泛型的时机：在创建对象的时候确定泛型

含有泛型的方法
定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

//步骤一：自定义含有泛型的方法
public class MyGenericMethod {	  
    public <MVP> void show(MVP mvp) {
    	System.out.println(mvp.getClass());
    }
    
    public <MVP> MVP show2(MVP mvp) {	
    	return mvp;
    }
}
//步骤二：在main方法中创建对象，调用方法：
public class GenericMethodDemo {
	public static void main(String[] args) {
        // 创建对象
        MyGenericMethod mm = new MyGenericMethod();
        // 演示看方法提示
        mm.show("aaa");//class java.lang.String
        mm.show(123);//class java.lang.Integer
        mm.show(12.45);//class java.lang.Double
        System.out.println(demo.show2(12.45));//12.45
	}
}

确定泛型的时机：调用方法时，确定泛型的类型

含有泛型的接口
定义格式：

修饰符 interface接口名<代表泛型的变量> {  }

确定泛型的时机：
?i )定义类时确定泛型的类型

例如：
public class MyImp1 implements MyGenericInterface<String> {
	@Override
    public void add(String e) {
        // 省略...
    }

	@Override
	public String getE() {
		return null;
	}
}

?ii )始终不确定泛型的类型，直到创建对象时，确定泛型的类型

例如：
//1.定义类：
public class MyImp2<E> implements MyGenericInterface<E> {
	@Override
	public void add(E e) {
       	 // 省略...
	}

	@Override
	public E getE() {
		return null;
	}
}
//2.创建对象
public class GenericInterface {
    public static void main(String[] args) {
        MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");
    }
}

⑤泛型通配符
??当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

通配符基本使用
泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。
此时只能接受数据,不能往该集合中存储数据。
举个例子大家理解使用即可：
```
public static void main(String[] args) {
    Collection<Intger> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}
public static void getElement(Collection<?> coll){}
//？代表可以接收任意类型
```
注意:泛型不存在继承关系Collection<Object> list = new ArrayList<String>();这种是错误的。

通配符高级使用----受限泛型
之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

格式： 类型名称 <? extends 类 > 对象名称
意义： 只能接收该类型及其子类

泛型的下限：

格式： 类型名称 <? super 类 > 对象名称

意义： 只能接收该类型及其父类型

//比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类
public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement(list1);
    getElement(list2);//报错
    getElement(list3);
    getElement(list4);//报错
  
    getElement2(list1);//报错
    getElement2(list2);//报错
    getElement2(list3);
    getElement2(list4);
  
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}

2.集合中涉及的数据结构

⑴ 常见的数据结构

数据存储的常用结构有：栈、队列、数组、链表和红黑树等。

⑵栈

栈：stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。

简单的说：采用该结构的集合，对元素的存取有如下的特点：

先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。
栈的入口、出口的都是栈的顶端位置。

这里两个名词需要注意：

压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。
弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置

⑶ 队列

队列：queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。

简单的说，采用该结构的集合，对元素的存取有如下的特点：

先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，小火车过山洞，车头先进去，车尾后进去；车头先出来，车尾后出来。
队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口。

⑷ 数组

数组:Array,是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，有100个房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。

简单的说,采用该结构的集合，对元素的存取有如下的特点：

查找元素快：通过索引，可以快速访问指定位置的元素
增删元素慢
指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。如下图!
指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。如下图

⑸链表

链表:linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时i动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。我们常说的链表结构有单向链表与双向链表，那么这里给大家介绍的是单向链表。
在这里插入图片描述
简单的说，采用该结构的集合，对元素的存取有如下的特点：

多个结点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。
*
查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素
增删元素快：
- 增加元素：只需要修改连接下个元素的地址即可。
删除元素：只需要修改连接下个元素的地址即可。

⑹红黑树

二叉树：binary tree ,是每个结点不超过2的有序树（tree） 。

简单的理解，就是一种类似于我们生活中树的结构，只不过每个结点上都最多只能有两个子结点。

二叉树是每个节点最多有两个子树的树结构。顶上的叫根结点，两边被称作“左子树”和“右子树”。

如图：
在这里插入图片描述
我们要说的是二叉树的一种比较有意思的叫做红黑树，红黑树本身就是一颗二叉查找树，将节点插入后，该树仍然是一颗二叉查找树。也就意味着，树的键值仍然是有序的。

红黑树的约束:

节点可以是红色的或者黑色的
根节点是黑色的
叶子节点(特指空节点)是黑色的
每个红色节点的子节点都是黑色的
任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同

红黑树的特点: ?
速度特别快,趋近平衡树,查找叶子元素最少和最多次数不多于二倍

3.List集合

java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。
List接口特点：

它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

⑴ List接口中常用方法

List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操作集合的特有方法，如下：

public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
public E get(int index):返回集合中指定位置的元素。
public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。

public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

public class ListDemo {
    public static void main(String[] args) {
		// 创建List集合对象
    	List<String> list = new ArrayList<String>();
    	
    	// 往 尾部添加 指定元素
    	list.add("图图");
    	list.add("小美");
    	list.add("不高兴");
    	
    	System.out.println(list);
    	// add(int index,String s) 往指定位置添加
    	list.add(1,"没头脑");
    	
    	System.out.println(list);
    	// String remove(int index) 删除指定位置元素  返回被删除元素
    	// 删除索引位置为2的元素 
    	System.out.println("删除索引位置为2的元素");
    	System.out.println(list.remove(2));
    	
    	System.out.println(list);
    	
    	// String set(int index,String s)
    	// 在指定位置 进行 元素替代（改） 
    	// 修改指定位置元素
    	list.set(0, "三毛");
    	System.out.println(list);
    	
    	// String get(int index)  获取指定位置元素
    	
    	// 跟size() 方法一起用  来 遍历的 
    	for(int i = 0;i<list.size();i++){
    		System.out.println(list.get(i));
    	}
    	//还可以使用增强for
    	for (String string : list) {
			System.out.println(string);
		}  	
	}
}

4.List的子类

⑴ ArrayList集合

java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。

⑵ LinkedList集合

java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。

LinkedList是一个双向链表，那么双向链表是什么样子的呢，我们用个图了解下

实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。这些方法我们作为了解即可：

public void addFirst(E e):将指定元素插入此列表的开头。
public void addLast(E e):将指定元素添加到此列表的结尾。
public E getFirst():返回此列表的第一个元素。
public E getLast():返回此列表的最后一个元素。
public E removeFirst():移除并返回此列表的第一个元素。
public E removeLast():移除并返回此列表的最后一个元素。
public E pop():从此列表所表示的堆栈处弹出一个元素。
public void push(E e):将元素推入此列表所表示的堆栈。

public boolean isEmpty()：如果列表不包含元素，则返回true。

/*LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，
 *我们只需要了解LinkedList的特有方法即可。在开发时，LinkedList集合也可以作为堆栈，
 *队列的结构使用。
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<String>();
        //添加元素
        link.addFirst("abc1");
        link.addFirst("abc2");
        link.addFirst("abc3");
        System.out.println(link);
        // 获取元素
        System.out.println(link.getFirst());
        System.out.println(link.getLast());
        // 删除元素
        System.out.println(link.removeFirst());
        System.out.println(link.removeLast());

        while (!link.isEmpty()) { //判断集合是否为空
            System.out.println(link.pop()); //弹出集合中的栈顶元素
        }

        System.out.println(link);
    }
}

5.Set接口

java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

Set集合有多个子类，这里我们介绍其中的java.util.HashSet、java.util.LinkedHashSet这两个集合。

tips:Set集合取出元素的方式可以采用：迭代器、增强for。

⑴ HashSet集合介绍

java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。java.util.HashSet底层的实现其实是一个java.util.HashMap支持，由于我们暂时还未学习，先做了解。

HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于：hashCode与equals方法。

public class HashSetDemo {
    public static void main(String[] args) {
        //创建 Set集合
        HashSet<String>  set = new HashSet<String>();

        //添加元素
        set.add(new String("cba"));
        set.add("abc");
        set.add("bac"); 
        set.add("cba");  
        //遍历
        for (String name : set) {
            System.out.println(name);
        }
    }
}

输出结果如下，说明集合中不能存储重复元素：

cba
abc
bac

tips:根据结果我们发现字符串"cba"只存储了一个，也就是说重复的元素set集合不存储。

⑵ HashSet集合存储数据的结构（哈希表）

什么是哈希表呢？

在JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下图所示。
在这里插入图片描述
存储流程如下如：

总而言之，JDK1.8引入红黑树大程度优化了HashMap的性能，那么对于我们来讲保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。

⑶HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //一定要重写equals方法和hashcode方法
    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Student student = (Student) o;
        return age == student.age &&
               Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class HashSetDemo2 {
    public static void main(String[] args) {
        //创建集合对象   该集合中存储 Student类型对象
        HashSet<Student> stuSet = new HashSet<Student>();
        //存储 
        Student stu = new Student("于谦", 43);
        stuSet.add(stu);
        stuSet.add(new Student("郭德纲", 44));
        stuSet.add(new Student("于谦", 43));
        stuSet.add(new Student("郭麒麟", 23));
        stuSet.add(stu);

        for (Student stu2 : stuSet) {
            System.out.println(stu2);
        }
    }
}
执行结果：
Student [name=郭德纲, age=44]
Student [name=于谦, age=43]
Student [name=郭麒麟, age=23]

⑷LinkedHashSet

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？

在HashSet下面有一个子类java.util.LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。

//演示代码如下:
public class LinkedHashSetDemo {
	public static void main(String[] args) {
		Set<String> set = new LinkedHashSet<String>();
		set.add("bbb");
		set.add("aaa");
		set.add("abc");
		set.add("bbc");
        Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}
结果：
  bbb
  aaa
  abc
  bbc

⑸ 可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：

修饰符 返回值类型 方法名(参数类型... 形参名){  }

其实这个书写完全等价与

修饰符 返回值类型 方法名(参数类型[] 形参名){  }

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

JDK1.5以后。出现了简化操作。… 用在参数上，称之为可变参数。

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，再进行传递。这些动作都在编译.class文件时，自动完成了。

//代码演示：
public class ChangeArgs {
    public static void main(String[] args) {
        int[] arr = { 1, 4, 62, 431, 2 };
        int sum = getSum(arr);
        System.out.println(sum);
        //  6  7  2 12 2121
        // 求 这几个元素和 6  7  2 12 2121
        int sum2 = getSum(6, 7, 2, 12, 2121);
        System.out.println(sum2);
    }

    /*
     * 完成数组  所有元素的求和 原始写法
     
      public static int getSum(int[] arr){
        int sum = 0;
        for(int a : arr){
            sum += a;
        }
        
        return sum;
      }
    */
    //可变参数写法
    public static int getSum(int... arr) {
        int sum = 0;
        for (int a : arr) {
            sum += a;
        }
        return sum;
    }
}

tips: 上述getSum方法在同一个类中，只能存在一个。因为会发生调用的不确定性
注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置。

⑹ .java.utils.Collections工具类

java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：

public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。

//代码演示：
public class CollectionsDemo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        //原来写法
        //list.add(12);
        //list.add(14);
        //list.add(15);
        //list.add(1000);
        //采用工具类 完成 往集合中添加元素  
        Collections.addAll(list, 5, 222, 1，2);
        System.out.println(list);
        //排序方法 
        Collections.sort(list);
        System.out.println(list);
    }
}
结果：
[5, 222, 1, 2]
[1, 2, 5, 222]

代码演示之后，发现我们的集合按照顺序进行了排列，可是这样的顺序是采用默认的顺序，如果想要指定顺序那该怎么办呢？

我们发现还有个方法没有讲，public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。接下来讲解一下指定规则的排列。

Comparator比较器

我们还是先研究这个方法

public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。

不过这次存储的是字符串类型。
```
public class CollectionsDemo2 {
    public static void main(String[] args) {
        ArrayList<String>  list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法
        Collections.sort(list);
        System.out.println(list);
    }
}
```
结果：
```
[aba, cba, nba, sba]
```
我们使用的是默认的规则完成字符串的排序，那么默认规则是怎么定义出来的呢？
说到排序了，简单的说就是两个对象之间比较大小，那么在JAVA中提供了两种比较实现的方式，一种是比较死板的采用java.lang.Comparable接口去实现，一种是灵活的当我需要做排序的时候在去选择的java.util.Comparator接口完成。

那么我们采用的public static <T> void sort(List<T> list)这个方法完成的排序，实际上要求了被排序的类型需要实现Comparable接口完成比较的功能，在String类型上如下：
```
public final class String implements java.io.Serializable,
 Comparable<String>, CharSequence {
```
String类实现了这个接口，并完成了比较规则的定义，但是这样就把这种规则写死了，那比如我想要字符串按照第一个字符降序排列，那么这样就要修改String的源代码，这是不可能的了，那么这个时候我们可以使用

public static <T> void sort(List<T> list，Comparator<? super T> )方法灵活的完成，这个里面就涉及到了Comparator这个接口，位于java.util包下，排序是comparator能实现的功能之一,该接口代表一个比较器，比较器具有可比性！顾名思义就是做排序的，通俗地讲需要比较两个对象谁排在前谁排在后，那么比较的方法就是：
- public int compare(String o1, String o2)：比较其两个参数的顺序。
  
  如果要按照升序排序，
  o1 - o2
  如果要按照降序排序
  o2 - o1
```
//操作如下:
public class CollectionsDemo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法  按照第一个单词的降序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //return o1.charAt(0) - o2.charAt(0);//升序
                return o2.charAt(0) - o1.charAt(0);//降序
            }
        });
        System.out.println(list);
    }
}
```
  结果如下：
```
[sba, nba, cba, aba]
```
- 简述Comparable和Comparator两个接口的区别。
  
  Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
  
  Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

练习:实现自定义对象的排序

创建一个学生类，存储到ArrayList集合中完成指定排序操作。

Student 初始类

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
               "name='" + name + '\'' +
               ", age=" + age +
               '}';
    }
}

测试类：

public class Demo {

    public static void main(String[] args) {
        // 创建四个学生对象 存储到集合中
        ArrayList<Student> list = new ArrayList<Student>();

        list.add(new Student("rose",18));
        list.add(new Student("jack",16));
        list.add(new Student("abc",16));
        list.add(new Student("ace",17));
        list.add(new Student("mark",16));


        /*
          让学生 按照年龄排序 升序
         */
//        Collections.sort(list);//要求 该list中元素类型  必须实现比较器Comparable接口


        for (Student student : list) {
            System.out.println(student);
        }


    }
}

发现，当我们调用Collections.sort()方法的时候程序报错了。
原因：如果想要集合中的元素完成排序，那么必须要实现比较器Comparable接口。
于是我们就完成了Student类的一个实现，如下： public class Student implements
Comparable{
…
@Override
public int compareTo(Student o) {
//return this.age-o.age;//升序
return o.age-this.age;//降序
} }

代码修改方式1：自定类实现Comparable接口
代码如下：

//自定的实体类
package com.kejizhentan;
//实现Comparable接口,接口的泛型是自定义类型
public class Student implements  Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //return this.age - o.age;//升序
        return o.age - this.age;//降序
    }
}

//测试类
package com.kejizhentan;

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

public class CollectionTest {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        Collections.addAll(list,new Student("zhangsan",18),new Student("lisi",21),new Student("wangwu",11));
        Collections.sort(list);
        System.out.println(list);
    }
}


//结果：
// [Student{name='lisi', age=21}, Student{name='zhangsan', age=18}, Student{name='wangwu', age=11}]

代码修改方式2:如果在使用的时候，想要独立的定义规则去使用可以采用Collections.sort(List list,Comparetor c)方式，自己定义规则,这时候自定类不实现Comparable接口

Collections.sort(list, new Comparator() {
@Override
public int compare(Student o1, Student o2) {
return o2.getAge()-o1.getAge();//以学生的年龄降序 }

代码示例如下：

package com.kejizhentan;
//自定类不用实现Comparable接口
public class Student{
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

}

//代码实现类
package com.kejizhentan;

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

public class CollectionTest {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        Collections.addAll(list,new Student("zhangsan",18),new Student("lisi",21),new Student("wangwu",11),new Student("xiaoming",21));
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //return o1.getAge() - o2.getAge();//升序
                return o2.getAge() - o1.getAge();//降序
            }
        });
        System.out.println(list);
    }
}

//结果：
[Student{name='lisi', age=21}, Student{name='xiaoming', age=21}, Student{name='zhangsan', age=18}, Student{name='wangwu', age=11}]

如果想要规则更多一些，可以参考下面代码：

public class CollectionTest {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        Collections.addAll(list,new Student("zhangsan",18),new Student("lisi",21),new Student("wangwu",11),new Student("xiaoming",21));
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //按年龄降序
                int result = o2.getAge() - o1.getAge();//降序
                if(result == 0){
                    //如果年龄相等，按姓名首字母排序（升序）
                    result = o1.getName().charAt(0) - o2.getName().charAt(0);
                }
                return  result;
            }
        });
        System.out.println(list);
    }
}
//结果如下：
//[Student{name='lisi', age=21}, Student{name='xiaoming', age=21}, Student{name='zhangsan', age=18}, Student{name='wangwu', age=11}]

⑺ java.util.Arrays类分装了所有操作数组的方法

static Object[] copyOf(Object[] original, int newLength)
返回一个从头开始复制长度为 newLength的新数组
static void sort(Object[] a)
对指定类型的数组按数字升序进行排序。
static List<T> asList(Object[] obj)
将指定的数组转换成List集合

此方法同 Collection.toArray() 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。

//例如：
public class CollectionTest {
    public static void main(String[] args) {
        String[] str = {"d","a","c","b","e"};
        String[] str2 = Arrays.copyOf(str, 4);
        for (String s : str2) {
            System.out.print(s+",");
        }
        System.out.println("");
        System.out.println("----------------------------------------------------------");
        Arrays.sort(str2);
        for (String s : str2) {
            System.out.print(s+",");
        }
        System.out.println("");
        System.out.println("----------------------------------------------------------");
        List<String> list = Arrays.asList(str2);
        System.out.println(list);
    }

6.双列集合Map

⑴ 存储特点：以键值对(key-value)形式存储
在这里插入图片描述
⑵Map常用子类
通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。

HashMap：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
LinkedHashMap：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

tips：Map接口中的集合都有两个泛型变量,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量的数据类型可以相同，也可以不同。

⑶ Map接口中的常用方法
Map接口中定义了很多方法，常用的如下：
public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
public V remove(Object key) : 把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

//案例：
public class CollectionTest {
    public static void main(String[] args) {
        //创建 map对象
        HashMap<String, String> map = new HashMap<>();
        //添加元素到集合
        //添加元素到集合
        map.put("黄晓明", "杨颖");
        map.put("文章", "马伊琍");
        map.put("邓超", "孙俪");
        System.out.println(map);
        //String remove(String key)
        System.out.println(map.remove("邓超"));
        System.out.println(map);
        // 想要查看 黄晓明的媳妇 是谁
        System.out.println(map.get("黄晓明"));
        System.out.println(map.get("邓超"));
        System.out.println(map.put("黄晓明", "张三"));
        System.out.println(map);
    }
}
//结果：
	/*{邓超=孙俪, 文章=马伊琍, 黄晓明=杨颖}
	*孙俪
	*{文章=马伊琍, 黄晓明=杨颖}
	*杨颖
	*null
	*杨颖
	*{文章=马伊琍, 黄晓明=张三}
	*/

tips:
使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到
集合中；
若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的
值，替换成指定的新值。

⑷ Map集合遍历键找值方式
①方式一：通过Set<K> keySet() 获取key的集合
键找值方式：即通过元素中的键，获取键所对应的值
分析步骤：
?a. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。
?b. 遍历键的Set集合，得到每一个键。
?c. 根据键，获取键所对应的值。方法提示: get(K key)

public class CollectionTest {
    public static void main(String[] args) {
        //创建 map对象
        HashMap<String, String> map = new HashMap<>();
        //添加元素到集合
        //添加元素到集合
        map.put("黄晓明", "杨颖");
        map.put("文章", "马伊琍");
        map.put("邓超", "孙俪");
        Set<String> keySet = map.keySet();
        for (String s : keySet) {
            System.out.println(map.get(s));
        }
    }
}
//结果：
/*
*孙俪
*马伊琍
*杨颖
*/

遍历图解：
在这里插入图片描述
②方式二：通过Entry键值对对象
我们已经知道， Map 中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在 Map 中是一一对应关系，这一对对象又称做 Map 中的一个 Entry(项) 。 Entry 将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历 Map 集合时，就可以从每一个键值对（ Entry ）对象中获取对应的键与对应的值。既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

public K getKey() ：获取Entry对象中的键。
public V getValue()：获取Entry对象中的值。

在Map集合中也提供了获取所有Entry对象的方法：

public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。

操作步骤：
?a. 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示: entrySet() 。
?b. 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
?c. 通过键值对(Entry)对象，获取Entry对象中的键与值。方法提示: getkey() getValue()

//案例：
public class CollectionTest {
    public static void main(String[] args) {
        //创建 map对象
        HashMap<String, String> map = new HashMap<>();
        //添加元素到集合
        //添加元素到集合
        map.put("黄晓明", "杨颖");
        map.put("文章", "马伊琍");
        map.put("邓超", "孙俪");
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Map.Entry<String, String> es : entrySet) {
            String key = es.getKey();
            String value = es.getValue();
            System.out.println(key+"="+value);
        }
    }
}
/*
 *结果
 *邓超=孙俪
 *文章=马伊琍
 *黄晓明=杨颖
 */

遍历图解：
在这里插入图片描述

注意：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

⑸ HashMap存储自定义类型键值
练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到
map集合中。学生作为键, 家庭住址作为值。

注意，学生姓名相同并且年龄相同视为同一名学生

编写学生类：

package com.kejizhentan;

import java.util.Objects;

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的
    //hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

测试类：

package com.kejizhentan;

import java.util.*;

public class CollectionTest {
    public static void main(String[] args) {
        //1,创建Hashmap集合对象。
        Map<Student,String>map = new HashMap<Student,String>();
        //2,添加元素。
        map.put(new Student("lisi",28), "上海");
        map.put(new Student("wangwu",22), "北京");
        map.put(new Student("zhaoliu",24), "成都");
        map.put(new Student("zhouqi",25), "广州");
        map.put(new Student("wangwu",22), "南京");
        //3,取出元素。键找值方式
        Set<Student>keySet = map.keySet();
        for(Student key: keySet){
            String value = map.get(key);
            System.out.println(key.toString()+"....."+value);
        }

    }
}
/*
 *Student{name='zhaoliu', age=24}.....成都
 *Student{name='lisi', age=28}.....上海
 *Student{name='wangwu', age=22}.....南京
 *Student{name='zhouqi', age=25}.....广州
 */

当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的
hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。如果要保证map中存放的key和取出的顺序一致，可以使用 java.util.LinkedHashMap 集合来存放。

⑹ LinkedHashMap
我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？
在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

public class CollectionTest {
    public static void main(String[] args) {
        //创建 map对象
        LinkedHashMap<String, String> map = new LinkedHashMap<>();
        //添加元素到集合
        //添加元素到集合
        map.put("黄晓明", "杨颖");
        map.put("文章", "马伊琍");
        map.put("邓超", "孙俪");
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Map.Entry<String, String> es : entrySet) {
            String key = es.getKey();
            String value = es.getValue();
            System.out.println(key + "=" + value);
        }
    }
}
/*
 *黄晓明=杨颖
 *文章=马伊琍
 *邓超=孙俪
 */

6.JDK9对集合添加的优化

通常，我们在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。实例化集合，几个 add方法调用，使得代码重复。

public class CollectionTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("abc");
        list.add("def");
        list.add("ghi");
        System.out.println(list);

    }
}

Java 9，添加了几种集合工厂方法,更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。
例子：

public class CollectionTest {
    public static void main(String[] args) {
        List<String> list = List.of("aaa", "bgbb", "csdf");
        System.out.println(list);
        System.out.println("---------------------------------------------");
        Set<String> set = Set.of("aaa", "bbb", "ccc", "ddd");
        System.out.println(set);
        System.out.println("---------------------------------------------");
        Map<String, Integer> map = Map.of("zhangsan", 18, "lisi", 22, "wangwu", 28);
        System.out.println(map);
    }
}
/*
*结果：
*[aaa, bgbb, csdf]
*---------------------------------------------
*[ddd, ccc, bbb, aaa]
*---------------------------------------------
*{wangwu=28, zhangsan=18, lisi=22}
*/