该进阶知识整理于以下链接P215~P287：
https://www.bilibili.com/video/BV1uJ411k7wyp=215
感谢此老师倾囊相授
上一篇Java基础知识：https://blog.csdn.net//article/details/119547490
下一篇Java异常进阶02 https://blog.csdn.net//article/details/119827287
1 对象篇
1.1 Object类
java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。如果一个类没有特别指定父类，那么默认则继承自Object类。
1.1.1成员方法
两个重要重写方法：
toString方法
public String toString()：返回该对象的字符串表示。
toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。例如：java.util.Random@3f3afe78
问题：
由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式
解决：
重写它。
看一个类是否重写了toString方法，直接打印这个类对应对象的名字即可。
如果没有重写，则打印的就是对象的地址值（默认）。例如：object类 Random类
如果重写，那么就按照重写的方式打印。例如：ArrayList类 Scanner类
如果在写类时想要重写toString方法，在IntelliJ IDEA中，可以点击Code菜单中的Generate...，也可以使用快捷键alt+insert，点击toString()选项。选择需要包含的成员变量并确定。
equals方法
public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。这里的“相同”有默认和自定义两种方式。
返回值是布尔值，如果是基本数据类型比较的是值，如果是引用数据类型比较的是两个对象的地址值。
默认比较两个对象的地址值没有意义，所以我们需要重写equals方法，比较两个对象的属性值。
问题：
public boolean equals(Object obj)传入的参数是Object类型，在重写方法时隐含着一个多态，这样会无法使用子类特有的内容。
解决：使用向下转型
优化：
-
增加一个判断，在转型的过程中要考虑参数为空以及类型转换异常的问题。
-
增加一个判断，传递的参数obj是this本身，直接返回true
-
增加一个判断，传递的参数obj为null，直接返回false
import java.util.Objects;
public class Person {
private String name;
private int age;@Override public boolean equals(Object o) { // 如果对象地址一样，则认为相同 if (this == o) return true; // 如果参数为空，或者类型信息不一样，则认为不同 if (o == null || getClass() != o.getClass()) return false; // 转换为当前类型 Person person = (Person) o; // 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果 return age == person.age && Objects.equals(name, person.name); }}
在IntelliJ IDEA中，可以使用Code菜单中的Generate…选项，也可以使用快捷键alt+insert，并选择equals() and hashCode()进行自动代码生成。
注意事项
在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。
在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：
2 日期时间篇
2.1 Date类
1秒 = 1000毫秒
毫秒的作用：可以对时间和日期进行计算。时间原点时1970年1月1日 00：00：00 （英国格林威治）。
把毫秒转换为日期：
1天=24*60*60= 86400s = 86400*60=86400000毫秒
import java.util.Date;
public class Demo01Date {
public static void main(String[] args) {
// 获取当前系统时间到1970经历了多少毫秒
System.out.println(System.currentTimeMillis());
// 创建日期对象，获取当前的时间
System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2018
// 创建日期对象，把当前的毫秒值转成日期对象
System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
}
}
tips:在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串。
2.1.1 构造方法
Date类无参
分配date对象并初始化此对象，以当前时间为准
System.out.println(new Date());
// Tue Jan 16 14:37:35 CST 2018
Date类带参
（毫秒转日期）
传递毫秒值，把毫秒转换为Date日期
System.out.println(new Date(0L));
// Thu Jan 01 08:00:00 CST 1970
//中国和英国有时差8小时
2.1.2 成员方法
getTime方法
（日期转毫秒）
public long getTime() 把日期对象转换成对应的时间毫秒值。
2.2 DateFormat类
java.text.DateFormat：是日期/时间格式化子类的抽象类
作用：格式化（日期->文本），解析(文本->日期)
问题：
由于DateFormat为抽象类，不能直接使用
解决：
需要常用的子类java.text.SimpleDateFormat来创建对象。
而这个类需要一个模式（格式）来指定格式化或解析的标准。该类构造方法为：public SimpleDateFormat(String pattern)【用给定的模式和默认语言环境的日期格式符号构造。参数pattern是一个字符串，代表日期时间的自定义格式】。
2.2.1 格式
标识字母（区分大小写）
含义
y
年
M
月
d
日
H
时
m
分
s
秒
//String pattern例如
//"yyyy-M-dd HH : mm: ss"
//"yyyy年月dd日HH时mm分ss秒”
2.2.2 使用步骤
导包
import java.text.DateFormat
import java.text.SimpleDateFormat
import java.util.Date;
import java.text.ParseException;
创建对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd")
2.2.3 成员方法
一般使用步骤
- 创建日期格式化对象
- 选择究竟手里有的是new Date()对象还是文本。
如果手里有new Date()需要格式化，则为format方法，格式化结果为文本。
如果手里有文本需要解析为Date对象，则为parse方法，解析结果为Date对象。
format方法
将Date对象格式化为字符串文本。返回值String
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
把Date对象转换成String
*/
public class Demo03DateFormatMethod {
public static void main(String[] args) {
Date date = new Date();
// 创建日期格式化对象,在获取格式化对象时可以指定风格
DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
String str = df.format(date);
System.out.println(str); // 2008年1月23日
}
}
parse方法
将字符串解析为Date对象。返回值Date对象
注意要导包：import java.text.ParseException;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
把String转换成Date对象
*/
public class Demo04DateFormatMethod {
public static void main(String[] args) throws ParseException {
DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
String str = "2018年12月11日";
Date date = df.parse(str);
System.out.println(date); // Tue Dec 11 00:00:00 CST 2018
}
}
public Date parse(String source ) throws ParseExceptionparse方法本身就有异常，声明了一个异常叫ParseException解析异常。
如果字符串和构造方法中的模式不一样,那么程序就会抛出此异常，调用一个抛出了异常的方法，就必须的处理这个异常,要么throws继续声明抛出这一个异常,要么try . …catch自己处理这个异常。
IDEA使用快捷键alt＋enter使用第一种方法：throws这个异常。其余涉及这个函数的地方也得throw抛出异常。
2.3 计算自己出生多少天小案例（）
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) throws ParseException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的出生日期，格式为yyyy-MM-dd");
String birthdayDateString = sc.next();
//定义日期格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//利用parse将字符串转换为Date对象
Date birthadyDate = sdf.parse(birthdayDateString);
//通过调用getTime方法得到毫秒数
long birthdayHtime = birthadyDate.getTime();
//得到现在时间的Date对象
Date now = new Date();
long nowHtime = now.getTime();
//相减得到相差的毫秒数
long xiangcha = nowHtime-birthdayHtime;
System.out.print("你出生到现在已经：");
System.out.println(xiangcha/1000/60/60/24+"天");
}
}
2.4 Calender类
java.util.Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。
2.4.1 使用步骤
问题：
是一个抽象类。无法直接创建对象使用。
解决：
通过静态方法getInstance()创建，返回Calendar子类对象。
import java.util.Calendar;
public class Demo06CalendarInit {
public static void main(String[] args) {
Calendar cal = Calendar.getInstance();//隐藏多态写法
//此时返回的是当前时间的日历
}
}
2.4.2 成员方法
int field：日历类字段，可以使用Calendar类静态成员变量获取。
public int get(int field)：返回给定日历字段的值。public void set(int field, int value)：将给定的日历字段设置为给定值。public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。
Calendar类中提供很多成员常量，代表给定的日历字段：
字段值
含义
YEAR
年
MONTH
月**（从0开始，可以+1使用）**
DAY_OF_MONTH
月中的天（几号）
HOUR
时（12小时制）
HOUR_OF_DAY
时（24小时制）
MINUTE
分
SECOND
秒
DAY_OF_WEEK
周中的天（周几，周日为1，可以-1使用）
get/set方法
public int get(int field)
public void set(int field, int value)
// 创建Calendar对象
Calendar cal = Calendar.getInstance();
// 设置年
int year = cal.get(Calendar.YEAR);
// 设置月
int month = cal.get(Calendar.MONTH) + 1;//西方月份0-11 东方1-12
// 设置日
int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, 2020);
add方法
public abstract void add(int field, int amount)
add方法可以对指定日历字段的值进行加减操作，如果第二个参数为正数则加上偏移量，如果为负数则减去偏移量。代码如：
import java.util.Calendar;
public class Demo08CalendarMethod {
public static void main(String[] args) {
Calendar cal = Calendar.getInstance();
System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2018年1月17日
// 使用add方法
cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
cal.add(Calendar.YEAR, -3); // 减3年
System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2015年1月18日;
}
}
getTime方法
public Date getTime()
Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象。如果需要毫秒时刻，应该再在Date的基础上再调用getTime()
import java.util.Calendar;
import java.util.Date;
public class Demo09CalendarMethod {
public static void main(String[] args) {
Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
System.out.println(date); // Tue Jan 16 16:03:09 CST 2018
}
}
小贴士：
西方星期的开始为周日，中国为周一。
在Calendar类中，月份的表示是以0-11代表1-12月。
日期是有大小关系的，时间靠后，时间越大。
3 系统篇
3.1 System类
java.lang.System类中提供了大量的静态方法（lang包可以不导包直接调用），可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：
public static long currentTimeMillis()：返回以毫秒为单位的当前时间。public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。
3.1.1 成员方法
currentTimeMillis方法
实际上，currentTimeMillis方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值。还可以尝试用Date方法的getTime()实现。
import java.util.Date;
public class SystemDemo {
public static void main(String[] args) {
//获取当前时间毫秒值
System.out.println(System.currentTimeMillis()); // 1516090531144
}
}
arraycopy方法
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。
数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数，含义分别为：
参数序号
参数名称
参数类型
参数含义
1
src
Object
源数组
2
srcPos
int
源数组索引起始位置
3
dest
Object
目标数组
4
destPos
int
目标数组索引起始位置
5
length
int
复制元素个数
import java.util.Arrays;
public class Demo11SystemArrayCopy {
public static void main(String[] args) {
int[] src = new int[]{1,2,3,4,5};
int[] dest = new int[]{6,7,8,9,10};
System.arraycopy( src, 0, dest, 0, 3);
/*代码运行后：两个数组中的元素发生了变化
src数组元素[1,2,3,4,5]
dest数组元素[1,2,3,9,10]
*/
}
}
注意：以上例子这里的拷贝是深拷贝。在拷贝之后，若改变src[0]的数值为150，打印后会发现dest[0]仍是1。所以拷贝仅仅是值的拷贝。
但是：
- 对于一维数组来说，这种复制属性值传递，修改副本不会影响原来的值，这是深拷贝。
- 对于二维或者一维数组中存放的是对象时，复制结果是：一维的引用变量 传递给 副本的一维数组。修改副本时，会影响原来的数组，这是浅拷贝。
深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体，而不是引用。假设B复制了A，修改A的时候，看B是否发生变化：
如果B跟着也变了，说明是浅拷贝（修改堆内存中的同一个值）
如果B没有改变，说明是深拷贝（修改堆内存中的不同的值）
详细请阅览（本人已测试）：https://blog.csdn.net/youngogo/article/details/107689676
3.2 StringBuilder类
java.lang.StringBuilder（lang无需导包）
问题：
字符串是常量;它们的值在创建之后不能更改。字符串的底层是一个被final修饰的数组不能改变,是一个常量。private final byte[] value;
进行字符串相加，内存中就会有多个字符串，占用空间多，效率低下。
解决：
字符串缓冲区，它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。
StringBuffer和StringBuilder区别：
在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
源自：https://www.runoob.com/java/java-stringbuffer.html
3.2.1 构造方法
-
public StringBuilder()：构造一个空的StringBuilder容器。 -
public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。public class StringBuilderDemo {
public static void main(String[] args) {
StringBuilder sb1 = new StringBuilder();
System.out.println(sb1); // (空白)
// 使用带参构造
StringBuilder sb2 = new StringBuilder(“itcast”);
System.out.println(sb2); // itcast
}
}
3.2.2 成员方法
public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。public String toString()：将当前StringBuilder对象转换为String对象。
append方法
public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。所以一般用法直接使用无需接收返回值。
public class Demo02StringBuilder {
public static void main(String[] args) {
//创建对象
StringBuilder builder = new StringBuilder();
//public StringBuilder append(任意类型)
StringBuilder builder2 = builder.append("hello");
//对比一下
System.out.println("builder:"+builder);
System.out.println("builder2:"+builder2);
System.out.println(builder == builder2); //true
// 可以添加 任何类型
builder.append("hello");
builder.append("world");
builder.append(true);
builder.append(100);
// 在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。
// 这种时候，我们就可以把代码现在一起，如append方法一样，代码如下
//链式编程
builder.append("hello").append("world").append(true).append(100);
System.out.println("builder:"+builder);
}
}
备注：StringBuilder已经覆盖重写了Object当中的toString方法。
toString方法
StringBuilder和String可以相互转换：
String->StringB：使用StringB构造方法
StringB->String：使用StringB中的toString()
public class Demo16StringBuilder {
public static void main(String[] args) {
// 链式创建
StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
// 调用方法
String str = sb.toString();
System.out.println(str); // HelloWorldJava
}
}
4 包装类
Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率。然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：
基本类型
对应的包装类（位于java.lang包中,无需导包）
byte
Byte
short
Short
int
Integer
long
Long
float
Float
double
Double
char
Character
boolean
Boolean
4.1 装箱
从基本类型转换为对应的包装类对象。
4.1.1 构造方法
- Integer(int value）构造一个新分配的Integer对象，它表示指定的 int 值。
- Integer(String s）构造一个新分配的Integer对象，它表示String参数所指示的int值。传递的字符串,必须是基本类型的字符串,否则会抛出异常“100”正确 “a”抛异常
注意：此包装类重写了toString方法
4.1.2 静态方法
- static Integer valueOf(int i)：返回一个表示指定的int 值的Integer实例。
- static Integer valueOf (String s)：返回保存指定的String 的值的Integer对象。
基本数值---->包装对象
Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法
4.2 拆箱
从包装类对象转换为对应的基本类型。
包装对象---->基本数值
int num = i.intValue();
4.3 自动装箱与自动拆箱
由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。
自动装箱：直接把int类型的整数值赋值给包装类
自动拆箱：包装类无法直接参与运算，可以自动转换为基本类型的数据再进行计算。
例如：
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。
ArrayList<Integer> list = new ArrayList<>();
list.add(1);//自动装箱 list.add(new Interger(1))
int a = list.get(0);//自动拆箱 list.get(0).intValue()
4.4 基本类型和字符串类型之间的转换
4.4.1 基本类型->字符串
-
基本类型直接与””相连接即可；如：34+“”
-
使用包装类中的静态方法 static String toString(int i)返回一个表示指定整数的String对象
-
使用String类中的静态方法 static String valueOf(int i )返回Int参数的字符串表示形式
//基本类型–>字符串
string s1 = 100+“”;
System.out.println(s1+200);/ /100200
string s2 = Integer.tostring( i: 100)
System.out.println(s2+280);//100200
string s3 = string.valueof(100)
System.out.println(s3+200);/ /100200
4.4.2 字符串->基本类型
String转换成对应的基本类型
除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：
public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。
例如：
public class Demo18WrapperParse {
public static void main(String[] args) {
int num = Integer.parseInt("100");
int num = Integer.parseInt("a");//注意这样会报错
int num = Integer.parseInt('a');//这样也会报错，参数必须是字符串
}
}
5 Collection类
数组与集合的区别：
- 数组的长度是固定的。集合的长度是可变的。
- 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。
List集合︰有索引、可以存储重复元素、可以保证存取顺序
- ArrayList:底层是数组实现的，查询快、增删慢
- LinkedList:底层是链表实现的，查询慢、增删快
Set集合∶无索引、不可以存储重复元素、存取无序
- HashSet:底层是哈希表+(红黑树)实现的，无索引、不可以存储重复元素、存取无序LinkedHashSet:底层是哈希表+链表实现的，无索引、不可以存储重复元素、可以保证存取顺序
- TreeSet:底层是二叉树实现。一般用于排序
5.1 通用方法
java.util.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(): 把集合中的元素，存储到数组中。
5.2 一般步骤
创建集合对象
//使用了多态，重写了toString()方法
Collection<string> coll = new HashSet<>();//无序集合
System.out.println(coll);
调用方法
// 添加功能 boolean add(String s)
//一般都返回true，所以在此情况下一般可以不用接收
coll.add("小李广");
coll.add("扫地僧");
coll.add("石破天");
System.out.println(coll);
// void clear() 清空集合
coll.clear();
System.out.println("集合中内容为："+coll);
//boolean remove(E e) 删除在集合中的o元素
//删除成功返回true
System.out.println("删除石破天："+coll.remove("石破天"));
// boolean contains(E e) 判断o是否在集合中存在
//存在返回true
System.out.println("判断 扫地僧 是否在集合中"+coll.contains("扫地僧"));
// boolean isEmpty() 判断是否为空
//为空为true
System.out.println(coll.isEmpty());
// 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]);
}
6 Iterator迭代器
在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。
为什么叫迭代器？
在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
6.1 使用步骤
问题：
Iterator迭代器是一个接口，我们无法直接使用，需要使用实现类对象。
解决：
Collection类中有一个方法
public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。
步骤：
1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)。
2.使用Iterator接口中的方法hasNext判断还有没有下一个元素。
3.使用Iterator接口中的方法next取出集合中的下一个元素。
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循环
while(it.hasNext()){ //判断是否有迭代元素
String s = it.next();//获取迭代出的元素
System.out.println(s);
}
//还可以用for循环
for(Iterator<String> it2 = coll.iterator();it2.hasNext();){
String s = it.next();//获取迭代出的元素
System.out.println(s);
}
}
}
Tips：Iterator接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型。
6.2 成员方法
public E next():返回迭代的下一个元素。public boolean hasNext():如果仍有元素可以迭代，则返回 true。
在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。
6.3 增强for循环
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。
底层使用的也是迭代器，使用for循环格式，简化了迭代器的书写。
6.3.1 格式
for(元素的数据类型 变量 : Collection集合or数组){
//写操作代码
}
它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。
6.3.2 遍历数组
public class NBForDemo1 {
public static void main(String[] args) {
int[] arr = {3,5,6,87};
//使用增强for遍历数组
for(int a : arr){//a代表数组中的每个元素
System.out.println(a);
}
}
}
6.3.3 遍历集合
public class NBFor {
public static void main(String[] args) {
Collection<String> coll = new ArrayList<String>();
coll.add("小河神");
coll.add("老河神");
coll.add("神婆");
//使用增强for遍历
for(String s :coll){//接收变量s代表 代表被遍历到的集合元素
System.out.println(s);
}
}
}
tips: 新for循环必须有被遍历的目标。目标只能是Collection或者是数组。新式for仅仅作为遍历操作出现。
7 泛型
一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型。泛型可以看做一个变量，用来接收数据类型。
E e：Element元素
T t：Type类型
tips:一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。
7.1 使用泛型的好处
不使用泛型
好处：集合不使用泛型，默认的类型是Object类型，可以存储任意类型的数据
坏处：不安全回引发异常。举例：
public class GenericDemo2 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("abc");
list.add(5);
Iterator<String> it = list.iterator();
while(it.hasNext()){
//取出元素的类型也是obj
Object obj = it.next();
System.out.println(obj);
//想要使用String类特有的方法，length获取字符串的长度，不能使用。因为这是多态需要向下转型，转型的过程重需要用到instance of 否则很容易报错，这样很麻烦也不安全。
System.out.println(str.length());
}
}
}
使用泛型
好处：
- 将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
- 避免了类型强转的麻烦。
坏处：
泛型是什么类型。只能存储什么类型的数据
public class GenericDemo2 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("abc");
// list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
// 集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = it.next();
//当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
System.out.println(str.length());
}
}
}
7.2 泛型的定义和使用
7.2.1 定义含有泛型的类
定义格式：
修饰符 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();
}
}
7.2.2 定义含有泛型的方法
定义格式：
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }
一个小栗子：
public class MyGenericMethod {
public <MVP> void show(MVP mvp) {
System.out.println(mvp.getClass());
}
public <MVP> MVP show2(MVP mvp) {
return mvp;
}
//也可以定义静态方法后直接通过类名调用
//public static <MVP> void showstatic(MVP mvp){……}
}
使用格式：调用方法时，确定泛型的类型
public class GenericMethodDemo {
public static void main(String[] args) {
// 创建对象
MyGenericMethod mm = new MyGenericMethod();
// 演示看方法提示
mm.show("aaa");
mm.show(123);
mm.show(12.45);
//若有静态方法也可以调用以下
//MyGenericMethod.showstatic(1);
}
}
7.2.3 含有泛型的接口
定义格式：
修饰符 interface接口名<代表泛型的变量> { }
一个小栗子：
public interface MyGenericInterface<E>{
public abstract void add(E e);
public abstract E getE();
}
使用格式：
1、定义类时确定泛型的类型
例如
public class MyImp1 implements MyGenericInterface<String> {
@Override
public void add(String e) {
// 省略...
}
@Override
public String getE() {
return null;
}
}
此时，泛型E的值就是String类型。
使用：
//使用
public class GenericInterface {
public static void main(String[] args) {
MyImp1 my = new MyImp1();
my.add("aa");
}
}
2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型
例如
public class MyImp2<E> implements MyGenericInterface<E> {
@Override
public void add(E e) {
// 省略...
}
@Override
public E getE() {
return null;
}
}
确定泛型：
//使用
public class GenericInterface {
public static void main(String[] args) {
MyImp2<String> my = new MyImp2<String>();
my.add("aa");
}
}
7.2.4 泛型通配符
泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用,表示未知通配符。
public static void main(String[] args) {
ArrayList<Intger> list1 = new ArrayList<Integer>();
getElement(list1);
ArrayList<String> list2 = new ArrayList<String>();
getElement(list2);
}
public static void getElement(ArrayList<?> list){
Iterator<?> it = list.iterator();
while(it.hasNext()){
Object o = it.next();
System.out.println(o);
}
}
//？代表可以接收任意类型
有人说”？“这里填Object类型不行吗？不行，泛型没有继承概念。泛型不存在继承关系 Collection list = new ArrayList();这种是错误的。
通配符高级使用----受限泛型
之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在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){}
7.3 斗地主小案例（）
按照斗地主的规则，完成洗牌发牌的动作。
具体规则：
使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
-
准备牌：
牌可以设计为一个ArrayList,每个字符串为一张牌。
每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。
牌由Collections类的shuffle方法进行随机排序。 -
发牌
将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。
-
看牌
直接打印每个集合。
public class HelloWorld {
public static void main(String[] args) { //准备 //定义一个存储54张牌的ArrayList集合 泛型使用String ArrayList<String> poker = new ArrayList<>(); String[] colors = {"?","?","?","?"}; String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3",}; poker.add("大王"); poker.add("小王"); for (String number : numbers) { for (String color : colors) { poker.add(color+number); } } System.out.println(poker); //洗牌 Collections.shuffle(poker); //发牌 ArrayList<String> player01 = new ArrayList<>(); ArrayList<String> player02 = new ArrayList<>(); ArrayList<String> player03 = new ArrayList<>(); ArrayList<String> dipai = new ArrayList<>(); for (int i = 0; i < poker.size(); i++) { String p =poker.get(i); if(i>=51){ dipai.add(p); }else if(i%3==0){ player01.add(p); }else if(i%3==1){ player02.add(p); }else if (i%3==2){ player03.add(p); } } //看牌 System.out.println("player01:"+player01); System.out.println("player02:"+player02); System.out.println("player03:"+player03); System.out.println("dipai:"+dipai); }}
8 List集合
特点︰有索引、可以存储重复元素、可以保证存取顺序
java.util.List接口继承自Collection接口
tips:我们学习过List接口的子类java.util.ArrayList类，该类中的方法都是来自List中定义。
注意：操作索引的时候，一定要防止索引越界异常。异常会报错***IndexOutOfBoundsException
8.1 成员方法
public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。public E get(int index):返回集合中指定位置的元素。public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
TIps: List集合遍历有三种方式
8.2 子类
8.2.1 ArrayList集合
java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
此实现不是同步的，而是多线程的。
8.2.2 LinkedList集合
java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。
实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。这些方法我们作为了解即可：
public void addFirst(E e):将指定元素插入此列表的开头。public void addLast(E e):将指定元素添加到此列表的结尾。等效于add()；public E getFirst():返回此列表的第一个元素。public E getLast():返回此列表的最后一个元素。public E removeFirst():移除并返回此列表的第一个元素。public E removeLast():移除并返回此列表的最后一个元素。public E pop():从此列表所表示的堆栈处弹出一个元素。等效于removeFirst；public void push(E e):将元素推入此列表所表示的堆栈。等效于addFirst()public boolean isEmpty()：如果列表不包含元素，则返回true。
8.2.3 Vector集合
可以实现可增长的对象数组
与ArrayList联系：
1、ArrayList出现于jdk1.2，vector出现于1.0。两者底层的数据存储都使用的Object数组实现，因为是数组实现，所以具有查找快，增删慢的特点
2、继承的类实现的接口都是一样的，都继承了AbstractList类（继承后可以使用迭代器遍历），实现了RandomAccess(标记接口，标明实现该接口的list支持快速随机访问)，cloneable接口（标识接口，合法调用clone方法），serializable（序列化标识接口）
3、当两者容量不够时，都会进行对Object数组的扩容
源：https://blog.csdn.net/qq_37113604/article/details/80836025
与ArrayList区别：
ArrayList
Vector
实现原理
采用动态对象数组实现，默认构造方法创建了一个空数组
采用动态数组对象实现，默认构造方法创建了一个大小为10的对象数组
扩充的算法
第一次添加元素，扩展容量为10，之后的扩充算法：原来数组大小+原来数组的一半
当增量为0时，扩充为原来大小的2倍，当增量大于0时，扩充为原来大小+增量
建议
为了防止数组动态扩充次数过多，建议创建ArrayList时，给定初始容量。
为了防止数组动态扩充次数过多，建议创建Vector时，给定初始容量
线程
多线程中使用不安全，适合在单线程访问时使用，效率较高。
线程安全，适合在多线程访问时使用，效率较低
源：https://blog.csdn.net/u011419651/article/details/83831156
9 Set接口
java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。
特点：无索引、不可以存储重复元素、存取无序
tips:Set集合取出元素的方式可以采用：迭代器、增强for。
9.1 子类
9.1.1 HashSet集合
特点：
- 不允许存储重复的元素
- 没有索引,没有带索引的方法,也不能使用普通的f or循环遍历
- 是一个无序的集合,存储元素和取出元素的顺序有可能不一致
- 底层是一个哈希表结构(查询的速度非常的快)
哈希值：
是一个十进制的整数,由系统随机给出(就是对象的地址值,是一个逻辑地址,是模拟出来得到地址,不是数据实际存储的物理地址)在object类有一个方法,可以获取对象的哈希值。这个方法是Object’类中的int hashCode()方法，返回该对象的哈希码值。
哈希表：
在JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。
简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下图所示。
存储流程图：
总而言之，JDK1.8引入红黑树大程度优化了HashMap的性能，那么对于我们来讲保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。
创建自定义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;
}
//重写equals
@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));
//若没有重写equals方法则比较的是地址值，重写之后才是比较内容
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]
9.1.2 LinkedHashSet集合
在HashSet下面有一个子类java.util.LinkedHashSet，它是链表(记录元素的存储顺序)和哈希表(数组+链表/红黑树)组合的一个数据存储结构。
保证元素有序！
9.2 可变参数
可变参数:是JDK1.5之后出现的新特性。
如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，但是参数的个数不确定时，我们可以对其简化成如下格式：
修饰符 返回值类型 方法名(参数类型... 形参名){ }
其实这个书写完全等价与
修饰符 返回值类型 方法名(参数类型[] 形参名){ }
只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。
可变参数的原理:
可变参数底层就是一个数组,根据传递参数个数不同,会创建不同长度的数组,来存储这些参数传递的参数个数,可以是0个(不传递),1,2…多个
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;
}
}
注意：
1、一个方法的参数列表，只能有一个可变参数。
2、如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置。
10 Collections
java.util.Collection是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。
java.util.Collections是一个包装类。它包含有各种有关集合操作的静态方法（对集合的搜索、排序、线程安全化等），大多数方法都是用来处理线性表的。此类不能实例化，就像一个工具类，服务于Java的Collection框架。
源：https://blog.csdn.net/xiangyuenacha/article/details/84237663
10.1 常用方法
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> ):将集合中元素按照指定规则排序。
10.1.1 addALL和shuffle
10.1.2 sort(List<>)与Comparable
public static <T> void sort(List<T> list)
使用前提：被排序的集合里面存储的元素，必须实现Comparable（不写报错），在元素类里面要重写接口种的方法compareTo定义的排序的规则。
记住：implements Comparable必不可少要另添加上！！
public class Person(o) implements Comparable<Person>{
private String name;
private int agel
……
@Overrude
public int compareTo(Person o){
return 0;//认为元素都是相同的
return this.getAge() - o.getAge();//升序
return o.getAge() - this.getAge();//降序
}
}
Collections.sort(list03);//会按照list03类中重写的方式排序
10.1.3 Comparator比较器
在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，返回（负数），相等返回0，01大于02返回（正数）
如果要按照降序排序
则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）
基本类型重写 
一个字符串降序小栗子：
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 o2.charAt(0) - o1.charAt(0);
}
});
System.out.println(list);
}
}
//结果
//[sba, nba, cba, aba]
自定义类型重写
TIps：记得要重写toString方法，否则打印都是地址值
还可以在比较年龄的同时按照姓名排序比较（组合排序）
10.1.4 Comparable和Comparator两个接口的区别。
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
11 Map集合
现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。
- Map集合是一个双列集合，一个元素包含两个值(一个key,一个value)
- Map集合中的元素,key和value的数据类型可以相同,也可以不同
- Map集合中的元素,key是不允许重复的, value是可以重复的
- Map集合中的元素,key和vatue是一一对应
Collection集合和Map集合的区别：
Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。Collection中的集合称为单列集合，Map中的集合称为双列集合。- 需要注意的是，
Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
11.1 子类
通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。
- HashMap<K,V>：存储数据采用的哈希表（数组+单向链表/红黑树) 结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。查询速度特别快。
- LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
tips：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。
11.2 常用方法
public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。public V get(Object key)根据指定的键，在Map集合中获取对应的值。boolean containsKey(Object key)判断集合中是否包含指定的键。public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
11.2.1 put
public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
返回值：
存储键值对的时候,key不重复,返回值v是null
存储键值对的时候,key重复,会便用新的value替换map中重复的value,返回被替换的value值。
11.2.2 remove
public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
返回值：
key存在，返回被删除的值
key不存在，返回null
11.2.3 get
public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
返回值：
key存在，返回对应value值
key不存在，返回null
private static void show03(){
Map<String,Interger> map = new HashMap<>();
map.put("赵丽颖",160);
map.put("迪丽热巴",168);
Integer v1 = map.get("赵丽颖");//v1:160
Integer v3 = map.get("杨幂");//v3:null
Int v2 = map.get("倪妮");//自动拆箱为Int，但是不能赋值为null，会报错NullPointerException
//null可以赋值给包装类，但不能赋值给基本类型，所以以后尽可能多用包装类
}
11.2.4 containsKey
boolean containsKey(Object key) 判断集合中是否包含指定的键。
返回值：包含返回true，不包含返回false
11.2.5 Map集合遍历键找值方式
public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。把Map集合中所有的key取出来存储到Set集合中public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
键找值方式：即通过元素中的键，获取键所对应的值
分析步骤：
-
获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:
keyset() -
遍历键的Set集合，得到每一个键。
-
根据键，获取键所对应的值。方法提示:
get(K key)public class MapDemo01 {
public static void main(String[] args) {
//创建Map集合对象
HashMap<String, String> map = new HashMap<String,String>();
//添加元素到集合
map.put(“胡歌”, “霍建华”);
map.put(“郭德纲”, “于谦”);
map.put(“薛之谦”, “大张伟”);//获取所有的键 获取键集 Set<String> keys = map.keySet(); // 遍历键集 得到 每一个键 for (String key : keys) { //key 就是键 //获取对应值 String value = map.get(key); System.out.println(key+"的CP是："+value); } }}
一个小栗子（自定义类型）：
每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。
注意，学生姓名相同并且年龄相同视为同一名学生。
import java.util.Objects;
public class User{
private String name;
private int age;
public User() {
}
public User(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 boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return age == user.age &&
Objects.equals(name, user.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "User{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
}
public class HelloWorld {
public static void main(String[] args) {
Map<User,String> map = new HashMap<User,String>();
map.put(new User("lisi",28), "上海");
map.put(new User("wangwu",22), "北京");
map.put(new User("zhaoliu",24), "成都");
map.put(new User("zhouqi",25), "广州");
map.put(new User("wangwu",22), "南京");
Set<User> keySet = map.keySet();
for (User user : keySet) {
String value= map.get(user);
System.out.println(user.toString()+"……"+value);
}
}
}
//结果
User{name='zhaoliu', age=24}……成都
User{name='lisi', age=28}……上海
User{name='wangwu', age=22}……南京
User{name='zhouqi', age=25}……广州
11.3 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集合)。
11.3.1 Map集合遍历键值对方式
键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。
操作步骤：
-
获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:
entrySet()。 -
遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
-
通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示:
getkey() getValue()public class MapDemo02 {
public static void main(String[] args) {
// 创建Map集合对象
HashMap<String, String> map = new HashMap<String,String>();
// 添加元素到集合
map.put(“胡歌”, “霍建华”);
map.put(“郭德纲”, “于谦”);
map.put(“薛之谦”, “大张伟”);// 获取 所有的 entry对象 entrySet Set<Entry<String,String>> entrySet = map.entrySet(); // 遍历得到每一个entry对象 for (Entry<String, String> entry : entrySet) { // 解析 String key = entry.getKey(); String value = entry.getValue(); System.out.println(key+"的CP是:"+value); } }}
11.4 LinkedHashMap
HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？
在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。
public class LinkedHashMapDemo {
public static void main(String[] args) {
LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
map.put("邓超", "孙俪");
map.put("李晨", "范冰冰");
map.put("刘德华", "朱丽倩");
Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
System.out.println(entry.getKey() + " " + entry.getValue());
}
}
}
//结果：
邓超 孙俪
李晨 范冰冰
刘德华 朱丽倩
11.5 HashTable
**HashTable<K,V>**此类实现一个哈希表，任何非null对象都可以用作键或值。是最早期的双列结构。是同步的，线程安全的，单线程的（意味着速度慢）。
HashTabLe与HashMap区别联系：
HashTabLe：底层也是一个哈希表,是一个线程安全的集合,是单线程集合,速度慢
HashMap:底层是一个哈希表,是一个线程不安全的集合,是多线程的集合,速度快
HashMap集合(之前学的所有的集合):可以存储null值,null键
HashTabLe集合,不能存储null值, null键
HashTable和vector集合一样,在jdk1.2版本之后被更先进的集合(HashMap ,ArrayList)取代了
HashTable的子类Properties依然活跃在历史舞台。Properties集合是一个唯—和IO流相结合的集合
11.6 计算一个字符串中每个字符出现次数。()
分析：
-
获取一个字符串对象
-
创建一个Map集合，键代表字符，值代表次数。
-
遍历字符串得到每个字符。
-
判断Map中是否有该键。
-
如果没有，第一次出现，存储次数为1；如果有，则说明已经出现过，获取到对应的值进行++，再次存储。
-
打印最终结果
public class HelloWorld {
public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.print("请输入一个字符串："); String line = sc.next(); HashMap<Character,Integer> map = new HashMap<>(); for (char c : line.toCharArray()) { if(map.containsKey(c)){ Integer value = map.get(c); value++; map.put(c,value); } else{ map.put(c,1); } } for (Character character : map.keySet()) { Integer value1 = map.get(character); System.out.println(character+"出现的次数是："+value1); } }}
12 JDK9对集合添加的优化
通常，我们在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。 实例化集合，几个 add方法 调用，使得代码重复。
public class Demo01 {
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 HelloJDK9 {
public static void main(String[] args) {
Set<String> str1=Set.of("a","b","c");
//str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合
System.out.println(str1);
Map<String,Integer> str2=Map.of("a",1,"b",2);
System.out.println(str2);
List<String> str3=List.of("a","b");
System.out.println(str3);
}
}
需要注意以下两点：
- of方法只适用于List接口, set接口,Map接口,不适用于接接口的实现类
- of方法的返回值是一个不能改变的集合，集合不能再使用add, put方法添加元素,会抛出异常
- set接口和Map接口在调用of方法的时候,不能有重复的元素，否则会抛出异常
13 debug断点调试
f8:逐行执行程序
f7:进入到方法中
shift+f8:跳出方法
f9:跳到下一个断点,如果没有下一个断点,那么就结束程序
ctrl+f2:退出debug模式,停止程序
Console:切换到控制台
14 模拟斗地主洗牌发牌（）
- 组装54张扑克牌将
- 54张牌顺序打乱
- 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
- 查看三人各自手中的牌（按照牌的大小排序）和底牌
public class HelloWorld {
public static void main(String[] args) {
HashMap<Integer,String> poker = new HashMap<>();
ArrayList<Integer> pokerindex = new ArrayList<>();
List<String> colors = new ArrayList<>();
Collections.addAll(colors,"?","?","?","?");
List<String> numbers = new ArrayList<>();
Collections.addAll(numbers,"2","A","K","Q","J","10","9","8","7","6","5","4","3");
int index = 0;
poker.put(index,"大王");
pokerindex.add(index);
index++;
poker.put(index,"小王");
pokerindex.add(index);
index++;
for (String number : numbers) {
for (String color : colors) {
poker.put(index,color+index);
pokerindex.add(index);
index++;
}
}
System.out.println(poker);
System.out.println(pokerindex);
Collections.shuffle(pokerindex);
System.out.println(pokerindex);
ArrayList<Integer> player01 = new ArrayList<>();
ArrayList<Integer> player02 = new ArrayList<>();
ArrayList<Integer> player03 = new ArrayList<>();
ArrayList<Integer> dipai = new ArrayList<>();
for (int i = 0; i < pokerindex.size(); i++) {
Integer in = pokerindex.get(i);
if(i>=51){
dipai.add(in);
}else if(i%3==0){
player01.add(in);
}else if(i%3==1){
player02.add(in);
}else if(i%3==2){
player03.add(in);
}
}
Collections.sort(player01);
Collections.sort(player02);
Collections.sort(player03);
Collections.sort(dipai);
watch("小一",poker,player01);
watch("小二",poker,player02);
watch("小三",poker,player03);
watch("底牌",poker,dipai);
}
public static void watch(String name,HashMap<Integer,String> poker, ArrayList<Integer> list){
System.out.print(name+":");
for (Integer integer : list) {
String value = poker.get(integer);
System.out.print(value+" ");
}
System.out.println();
}
}
下一篇异常进阶02请查阅：
https://blog.csdn.net//article/details/119827287
最后
深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
家的负担。
小编已加密：aHR0cHM6Ly9kb2NzLnFxLmNvbS9kb2MvRFVrVm9aSGxQZUVsTlkwUnc==出于安全原因，我们把网站通过base64编码了，大家可以通过base64解码把网址获取下来。
193
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
