Java学习笔记Day06 工具类及常用算法
第六章 工具类及常用算法
文章目录
- 第六章 工具类及常用算法
- Java语言基础类
- Java基础类库
- Object类
- 概述
- toString方法
- 方法摘要
- 覆盖重写
- equals方法
- 方法摘要
- 默认地址比较
- 对象内容比较
- Objects类
- Math类
- 概述
- 基本运算的方法
- 日期时间类
- Date类
- 概述
- 常用方法
- DateFormat类
- 构造方法
- 格式规则
- 常用方法
- format方法
- parse方法
- Calendar类
- 概念
- 获取方式
- 常用方法
- get/set方法
- add方法
- getTime方法
- 新版日期API
- System类
- currentTimeMillis方法
- arraycopy方法
- StringBuilder类
- 字符串拼接问题
- StringBuilder概述
- 构造方法
- 常用方法
- append方法
- toString方法
- Arrays类
- 概述
- 操作数组的方法
- ArrayList类
- 引入 --对象数组
- ArrayList使用步骤
- 常用方法和遍历
- Collection集合
- 集合概述
- 集合框架
- Collection 常用功能
- Iterator迭代器
- Iterator接口
- 迭代器的实现原理
- 增强for
- 练习1:遍历数组
- 练习2:遍历集合
- 数据结构
- 常见的数据结构
- 栈
- 队列
- 数组
- 链表
- 红黑树
- List集合
- List接口介绍
- List接口中常用方法
- List的子类
- ArrayList集合
- LinkedList集合
- Set接口
- HashSet集合介绍
- HashSet集合存储数据的结构(哈希表)
- HashSet存储自定义类型元素
- LinkedHashSet
- 可变参数
- Collections
- 常用功能
- Comparator比较器
- 简述Comparable和Comparator两个接口的区别。
- 扩展
- Map集合
- 概述
- Map常用子类
- Map接口中的常用方法
- Map集合遍历键找值方式
- Entry键值对对象
- Map集合遍历键值对方式
- HashMap存储自定义类型键值
- LinkedHashMap
- 补充知识点
- JDK9对集合添加的优化
- 泛型
- 如何存储基本数据类型
- 泛型概述
- 使用泛型的好处
- 泛型的定义与使用
- 定义和使用含有泛型的类
- 含有泛型的方法
- 含有泛型的接口
- 泛型通配符
- 通配符基本使用
- 通配符高级使用----受限泛型
- 常用算法
- 遍试(穷举,exhaust algorithm)
- 遍历算法的基本模式
- 迭代(iterative algorithm)
- 迭代的基本模式
- 递归(recursive)
- 递归算法的基本模式
- 回溯(back-track)
- 回溯法的基本模式
Java语言基础类
Java基础类库
java.lang
:Java语言的核心类库
java.util
:实用工具
java.io
:标准输入/输出类库
java.awt
java.net
:网络功能的类库
java.sql
:数据库访问的类库
Object类
概述
java.lang.Object
类是Java语言中的根类,即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候,最终找的父类就是Object。
如果一个类没有特别指定父类,那么默认则继承自Object类。例如:
public class MyClass /*extends Object*/ {// ...
}
根据JDK源代码及Object类的API文档,Object类当中包含的方法有11个。主要学习其中的2个:
public String toString()
:返回该对象的字符串表示。public boolean equals(Object obj)
:指示其他某个对象是否与此对象“相等”。
toString方法
方法摘要
public String toString()
:返回该对象的字符串表示。
toString方法返回该对象的字符串表示,其实该字符串内容就是对象的类型+@+内存地址值。
由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表现形式,因此也需要重写它。
覆盖重写
如果不希望使用toString方法的默认行为,则可以对它进行覆盖重写。例如自定义的Person类:
public class Person { private String name;private int age;@Overridepublic String toString() {return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';}// 省略构造器与Getter Setter
}
在IntelliJ IDEA中,可以点击Code
菜单中的Generate...
,也可以使用快捷键alt+insert
,点击toString()
选项。选择需要包含的成员变量并确定。如下图所示:
小贴士: 在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。
equals方法
方法摘要
public boolean equals(Object obj)
:指示其他某个对象是否与此对象“相等”。
调用成员方法equals并指定参数为另一个对象,则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。
默认地址比较
如果没有覆盖重写equals方法,那么Object类中默认进行==
运算符的对象地址比较,只要不是同一个对象,结果必然为false。
对象内容比较
如果希望进行对象的内容比较,即所有或指定的部分成员变量相同就判定两个对象相同,则可以覆盖重写equals方法。例如:
import java.util.Objects;public class Person { private String name;private int age;@Overridepublic 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);}
}
这段代码充分考虑了对象为空、类型一致等问题,但方法内容并不唯一。大多数IDE都可以自动生成equals方法的代码内容。在IntelliJ IDEA中,可以使用Code
菜单中的Generate…
选项,也可以使用快捷键alt+insert
,并选择equals() and hashCode()
进行自动代码生成。
tips:Object类当中的hashCode等其他方法,今后学习。
Objects类
在刚才IDEA自动重写equals代码中,使用到了java.util.Objects
类,那么这个类是什么呢?
在JDK7添加了一个Objects工具类,它提供了一些方法来操作对象,它由一些静态的实用方法组成,这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的),用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。
在比较两个对象的时候,Object的equals方法容易抛出空指针异常,而Objects类中的equals方法就优化了这个问题。方法如下:
public static boolean equals(Object a, Object b)
:判断两个对象是否相等。
我们可以查看一下源码,学习一下:
public static boolean equals(Object a, Object b) { return (a == b) || (a != null && a.equals(b));
}
Math类
概述
java.lang.Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。类似这样的工具 类,其所有方法均为静态方法,并且不会创建对象,调用起来非常简单。
基本运算的方法
public static double abs(double a) :返回 double 值的绝对值。
double d1 = Math.abs(‐5); //d1的值为5 double d2 = Math.abs(5); //d2的值为5
public static double ceil(double a) :返回大于等于参数的小的整数。
double d1 = Math.ceil(3.3); //d1的值为 4.0 double d2 = Math.ceil(‐3.3); //d2的值为‐3.0 double d3 = Math.ceil(5.1); //d3的值为 6.0
public static double floor(double a) :返回小于等于参数大的整数。
double d1 = Math.floor(3.3); //d1的值为3.0 double d2 = Math.floor(‐3.3); //d2的值为‐4.0 double d3 = Math.floor(5.1); //d3的值为 5.0
public static long round(double a) :返回接近参数的 long。(相当于四舍五入方法)
long d1 = Math.round(5.5); //d1的值为6.0 long d2 = Math.round(5.4); //d2的值为5.0
public class MathTest { public static void main(String[] args) { // 定义小值 double min = ‐10.8; // 定义大值 double max = 5.9; // 定义变量计数 int count = 0; // 范围内循环 for (double i = Math.ceil(min); i <= max; i++) { // 获取绝对值并判断 if (Math.abs(i) > 6 || Math.abs(i) < 2.1) { // 计数 count++; } } System.out.println("个数为: " + count + " 个"); }
}
日期时间类
Date类
概述
java.util.Date
类 表示特定的瞬间,精确到毫秒。
继续查阅Date类的描述,发现Date拥有多个构造函数,只是部分已经过时,但是其中有未过时的构造函数可以把毫秒值转成日期对象。
public Date()
:分配Date对象并初始化此对象,以表示分配它的时间(精确到毫秒)。public Date(long date)
:分配Date对象并初始化此对象,以表示自从标准基准时间(称为“历元(epoch)”,即1970年1月1日00:00:00 GMT)以来的指定毫秒数。
由于我们处于东八区,所以我们的基准时间为1970年1月1日8时0分0秒。
简单来说:使用无参构造,可以自动设置当前系统时间的毫秒时刻;指定long类型的构造参数,可以自定义毫秒时刻。例如:
import java.util.Date;public class Demo01Date {public static void main(String[] args) {// 创建日期对象,把当前的时间System.out.println(new Date());// 创建日期对象,把当前的毫秒值转成日期对象System.out.println(new Date(0L)); }
}
tips:在使用println方法时,会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写,所以结果为指定格式的字符串。
常用方法
Date类中的多数方法已经过时,常用的方法有:
public long getTime()
把日期对象转换成对应的时间毫秒值。
DateFormat类
java.text.DateFormat
是日期/时间格式化子类的抽象类,我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。
- 格式化:按照指定的格式,从Date对象转换为String对象。
- 解析:按照指定的格式,从String对象转换为Date对象。
构造方法
由于DateFormat为抽象类,不能直接使用,所以需要常用的子类java.text.SimpleDateFormat
。这个类需要一个模式(格式)来指定格式化或解析的标准。构造方法为:
public SimpleDateFormat(String pattern)
:用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
参数pattern
是一个字符串,代表日期时间的自定义格式。
格式规则
常用的格式规则为:
标识字母(区分大小写) | 含义 |
---|---|
y | 年 |
M | 月 |
d | 日 |
H | 时 |
m | 分 |
s | 秒 |
备注:更详细的格式规则,可以参考SimpleDateFormat类的API文档。
创建SimpleDateFormat对象的代码如:
import java.text.DateFormat;
import java.text.SimpleDateFormat;public class Demo02SimpleDateFormat {public static void main(String[] args) {// 对应的日期格式如:2020-04-27 15:06:38DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");}
}
常用方法
DateFormat类的常用方法有:
public String format(Date date)
:将Date对象格式化为字符串。public Date parse(String source)
:将字符串解析为Date对象。
format方法
使用format方法的代码为:
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); // 2020年4月26日}
}
parse方法
使用parse方法的代码为:
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}
}
Calendar类
概念
日历我们都见过
java.util.Calendar
是日历类,在Date后出现,替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量,方便获取。日历类就是方便获取各个时间属性的。
获取方式
Calendar为抽象类,由于语言敏感性,Calendar类在创建对象时并非直接创建,而是通过静态方法创建,返回子类对象,如下:
Calendar静态方法
public static Calendar getInstance()
:使用默认时区和语言环境获得一个日历
例如:
import java.util.Calendar;public class Demo06CalendarInit {public static void main(String[] args) {Calendar cal = Calendar.getInstance();}
}
常用方法
根据Calendar类的API文档,常用方法有:
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方法
get方法用来获取指定字段的值,set方法用来设置指定字段的值,代码使用演示:
import java.util.Calendar;public class CalendarUtil {public static void main(String[] args) {// 创建Calendar对象Calendar cal = Calendar.getInstance();// 设置年 int year = cal.get(Calendar.YEAR);// 设置月int month = cal.get(Calendar.MONTH) + 1;// 设置日int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);System.out.print(year + "年" + month + "月" + dayOfMonth + "日");}
}
import java.util.Calendar;public class Demo07CalendarMethod {public static void main(String[] args) {Calendar cal = Calendar.getInstance();cal.set(Calendar.YEAR, 2020);System.out.print(year + "年" + month + "月" + dayOfMonth + "日");}
}
add方法
add方法可以对指定日历字段的值进行加减操作,如果第二个参数为正数则加上偏移量,如果为负数则减去偏移量。代码如:
import java.util.Calendar;public class Demo08CalendarMethod {public static void main(String[] args) {Calendar cal = Calendar.getInstance();System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 使用add方法cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天cal.add(Calendar.YEAR, -3); // 减3年System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); }
}
getTime方法
Calendar中的getTime方法并不是获取毫秒时刻,而是拿到对应的Date对象。
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); }
}
西方星期的开始为周日,中国为周一。
在Calendar类中,月份的表示是以0-11代表1-12月。
日期是有大小关系的,时间靠后,时间越大。
新版日期API
System类
java.lang.System
类中提供了大量的静态方法,可以获取与系统相关的信息或系统级操作,在System类的API文档中,常用的方法有:
public static long currentTimeMillis()
:返回以毫秒为单位的当前时间。public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
:将数组中指定的数据拷贝到另一个数组中。
currentTimeMillis方法
实际上,currentTimeMillis方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值
import java.util.Date;public class SystemDemo {public static void main(String[] args) {//获取当前时间毫秒值System.out.println(System.currentTimeMillis()); }
}
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 | 复制元素个数 |
StringBuilder类
字符串拼接问题
由于String类的对象内容不可改变,所以每当进行字符串拼接时,总是会在内存中创建一个新的对象。例如:
public class StringDemo {public static void main(String[] args) {String s = "Hello";s += "World";System.out.println(s);}
}
在API中对String类有这样的描述:字符串是常量,它们的值在创建后不能被更改。
根据这句话分析我们的代码,其实总共产生了三个字符串,即"Hello"
、"World"
和"HelloWorld"
。引用变量s首先指向Hello
对象,最终指向拼接出来的新字符串对象,即HelloWord
。
由此可知,如果对字符串进行拼接操作,每次拼接,都会构建一个新的String对象,既耗时,又浪费空间。为了解决这一问题,可以使用java.lang.StringBuilder
类。
StringBuilder概述
查阅java.lang.StringBuilder
的API,StringBuilder又称为可变字符序列,它是一个类似于 String 的字符串缓冲区,通过某些方法调用可以改变该序列的长度和内容。
原来StringBuilder是个字符串的缓冲区,即它是一个容器,容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
它的内部拥有一个数组用来存放字符串内容,进行字符串拼接时,直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理如下图所示:(默认16字符空间,超过自动扩充)
构造方法
根据StringBuilder的API文档,常用构造方法有2个:
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("tao");System.out.println(sb2); // tao }
}
常用方法
StringBuilder常用的方法有2个:
public StringBuilder append(...)
:添加任意类型数据的字符串形式,并返回当前对象自身。public String toString()
:将当前StringBuilder对象转换为String对象。
append方法
append方法具有多种重载形式,可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。例如:
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方法
通过toString方法,StringBuilder对象将会转换为不可变的String对象。如:
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}
}
Arrays类
概述
java.util.Arrays
此类包含用来操作数组的各种方法,比如排序和搜索等。其所有方法均为静态方法,调用起来 非常简单。
操作数组的方法
public static String toString(int[] a)
:返回指定数组内容的字符串表示形式。
public static void main(String[] args) { // 定义int 数组 int[] arr = {2,34,35,4,657,8,69,9}; // 打印数组,输出地址值 System.out.println(arr); // [I@2ac1fdc4 // 数组内容转为字符串 String s = Arrays.toString(arr); // 打印字符串,输出内容 System.out.println(s); // [2, 34, 35, 4, 657, 8, 69, 9] }
public static void sort(int[] a)
:对指定的 int 型数组按数字升序进行排序。
public static void main(String[] args) { // 定义int 数组 int[] arr = {24, 7, 5, 48, 4, 46, 35, 11, 6, 2}; System.out.println("排序前:"+ Arrays.toString(arr)); // 排序前:[24, 7, 5, 48, 4, 46, 35, 11, 6, 2] // 升序排序 Arrays.sort(arr); System.out.println("排序后:"+ Arrays.toString(arr));// 排序后:[2, 4, 5, 6, 7, 11, 24, 35, 46, 48]
}
ArrayList类
引入 --对象数组
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; } publicvoid setName(String name) { this.name = name; } publicint getAge() { return age; } publicvoid setAge(int age) { this.age = age; }
} public class Test01StudentArray { public static void main(String[] args) { //创建学生数组 Student[] students = new Student[3]; //创建学生对象 Student s1 = new Student("曹操",40); Student s2 = new Student("刘备",35); Student s3 = new Student("孙权",30); //把学生对象作为元素赋值给学生数组 students[0] = s1; students[1] = s2; students[2] = s3; //遍历学生数组 for(int x=0; x<students.length; x++) { Student s = students[x]; System.out.println(s.getName()+"‐‐‐"+s.getAge()); } }
}
到目前为止,我们想存储对象数据,选择的容器,只有对象数组。而数组的长度是固定的,无法适应数据变化的需 求。为了解决这个问题,Java提供了另一个容器 java.util.ArrayList
集合类,让我们可以更便捷的存储和操作对 象数据。
ArrayList使用步骤
查看类
java.util.ArrayList <E>
:该类需要 import导入使后使用。
,表示一种指定的数据类型,叫做泛型。 E ,取自Element(元素)的首字母。在出现 E 的地方,我们使 用一种引用数据类型将其替换即可,表示我们将存储哪种引用类型的元素。代码如下:
ArrayList<String>,ArrayList<Student>
查看构造方法
public ArrayList()
:构造一个内容为空的集合。
基本格式:ArrayList<String> list = new ArrayList<>();
查看成员方法
public boolean add(E e)
: 将指定的元素添加到此集合的尾部。 参数E e
,在构造ArrayList对象时, 指定了什么数据类型,那么add(E e)
方法中,只能添加什么数据 类型的对象。
public class Test02StudentArrayList { public static void main(String[] args) { //创建学生数组 ArrayList<String> list = new ArrayList<>(); //创建学生对象 String s1 = "曹操"; String s2 = "刘备"; String s3 = "孙权"; //打印学生ArrayList集合 System.out.println(list); //把学生对象作为元素添加到集合 list.add(s1); list.add(s2); list.add(s3);//打印学生ArrayList集合 System.out.println(list); }
}
常用方法和遍历
对于元素的操作,基本体现在——增、删、查。常用的方法有:
public boolean add(E e)
:将指定的元素添加到此集合的尾部。public E remove(int index)
:移除此集合中指定位置上的元素。返回被删除的元素。public E get(int index)
:返回此集合中指定位置上的元素。返回获取的元素。public int size()
:返回此集合中的元素数。遍历集合时,可以控制索引范围,防止越界。
public class Demo01ArrayListMethod { public static void main(String[] args) { //创建集合对象 ArrayList<String> list = new ArrayList<String>(); //添加元素 list.add("hello"); list.add("world"); list.add("java"); //public E get(int index):返回指定索引处的元素 System.out.println("get:"+list.get(0)); System.out.println("get:"+list.get(1)); System.out.println("get:"+list.get(2)); //public int size():返回集合中的元素的个数 System.out.println("size:"+list.size()); //public E remove(int index):删除指定索引处的元素,返回被删除的元素 System.out.println("remove:"+list.remove(0)); //遍历输出 for(int i = 0; i < list.size(); i++){ System.out.println(list.get(i)); } }
}
Collection集合
集合概述
在前面基础班我们已经学习过并使用过集合ArrayList<E>
,那么集合到底是什么呢?
- 集合:集合是java中提供的一种容器,可以用来存储多个数据。
集合和数组既然都是容器,它们有啥区别呢?
- 数组的长度是固定的。集合的长度是可变的。
- 数组中存储的是同一类型的元素,可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候,使用集合进行存储。
集合框架
JAVASE提供了满足各种需求的API,在使用这些API前,先了解其继承与接口操作架构,才能了解何时采用哪个类,以及类之间如何彼此合作,从而达到灵活应用。
集合按照其存储结构可以分为两大类,分别是单列集合java.util.Collection
和双列集合java.util.Map
。
- Collection:单列集合类的根接口,用于存储一系列符合某种规则的元素,它有两个重要的子接口,分别是
java.util.List
和java.util.Set
。其中,List
的特点是元素有序、元素可重复。Set
的特点是元素无序,而且不可重复。
List
接口的主要实现类有java.util.ArrayList
和java.util.LinkedList
Set
接口的主要实现类有java.util.HashSet
和java.util.TreeSet
。
从上面的描述可以看出JDK中提供了丰富的集合类库,为了便于初学者进行系统地学习,接下来通过一张图来描述整个集合类的继承体系。
其中,橙色框里填写的都是接口类型,而蓝色框里填写的都是具体的实现类。
集合本身是一个工具,它存放在java.util
包中。在Collection
接口定义着单列集合框架中最最共性的内容。
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()); }
}
Iterator迭代器
Iterator接口
在程序开发中,经常需要遍历集合中的所有元素。针对这种需求,JDK专门提供了一个接口java.util.Iterator
。Iterator
接口也是Java集合中的一员,但它与Collection
、Map
接口有所不同,Collection
接口与Map
接口主要用于存储元素,而Iterator
主要用于迭代访问(即遍历)Collection
中的元素,因此Iterator
对象也被称为迭代器。
想要遍历Collection集合,那么就要获取该集合迭代器完成迭代操作,下面介绍一下获取迭代器的方法:
public Iterator iterator()
: 获取集合对应的迭代器,用来遍历集合中的元素的。
下面介绍一下迭代的概念:
- 迭代:即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素,如果有,就把这个元素取出来,继续在判断,如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
Iterator接口的常用方法如下:
public E next()
:返回迭代的下一个元素。public boolean hasNext()
:如果仍有元素可以迭代,则返回 true。
接下来我们通过案例学习如何使用Iterator迭代集合中元素:
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);}}
}
tips::在进行集合元素取出时,如果集合中已经没有元素了,还继续使用迭代器的next方法,将会发生java.util.NoSuchElementException没有集合元素的错误。
迭代器的实现原理
我们在之前案例已经完成了Iterator遍历集合的整个过程。当遍历集合时,首先通过调用t集合的iterator()
方法获得迭代器对象,然后使用hashNext()
方法判断集合中是否存在下一个元素,如果存在,则调用next()
方法将元素取出,否则说明已到达了集合末尾,停止遍历元素。
Iterator迭代器对象在遍历集合时,内部采用指针的方式来跟踪集合中的元素,为了让初学者能更好地理解迭代器的工作原理,接下来通过一个图例来演示Iterator对象迭代元素的过程:
在调用Iterator的next方法之前,迭代器的索引位于第一个元素之前,不指向任何元素,当第一次调用迭代器的next方法后,迭代器的索引会向后移动一位,指向第一个元素并将该元素返回,当再次调用next方法时,迭代器的索引会指向第二个元素并将该元素返回,依此类推,直到hasNext方法返回false,表示到达了集合的末尾,终止对元素的遍历。
增强for
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环,专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。
格式:
for(元素的数据类型 变量 : Collection集合or数组){ //写操作代码
}
它用于遍历Collection
和数组。通常只进行遍历元素,不要在遍历的过程中对集合元素进行增删操作。
练习1:遍历数组
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);}}
}
练习2:遍历集合
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);}}
}
新for循环必须有被遍历的目标。目标只能是Collection或者是数组。新式for仅仅作为遍历操作出现。
数据结构
常见的数据结构
数据存储的常用结构有:栈、队列、数组、链表和红黑树。我们分别来了解一下:
栈
- 栈:stack,又称堆栈,它是运算受限的线性表,其限制是仅允许在标的一端进行插入和删除操作,不允许在其他任何位置进行添加、查找、删除等操作。
简单的说:采用该结构的集合,对元素的存取有如下的特点
简单的说:采用该结构的集合,对元素的存取有如下的特点
先进后出(即,存进去的元素,要在后它后面的元素依次取出后,才能取出该元素)。例如,子弹压进弹夹,先压进去的子弹在下面,后压进去的子弹在上面,当开枪时,先弹出上面的子弹,然后才能弹出下面的子弹。
栈的入口、出口的都是栈的顶端位置。
这里两个名词需要注意:
- 压栈:就是存元素。即,把元素存储到栈的顶端位置,栈中已有元素依次向栈底方向移动一个位置。
- 弹栈:就是取元素。即,把栈的顶端位置元素取出,栈中已有元素依次向栈顶方向移动一个位置。
队列
- 队列:queue,简称队,它同堆栈一样,也是一种运算受限的线性表,其限制是仅允许在表的一端进行插入,而在表的另一端进行删除。
简单的说,采用该结构的集合,对元素的存取有如下的特点:
- 先进先出(即,存进去的元素,要在后它前面的元素依次取出后,才能取出该元素)。例如,小火车过山洞,车头先进去,车尾后进去;车头先出来,车尾后出来。
- 队列的入口、出口各占一侧。例如,下图中的左侧为入口,右侧为出口。
数组
- 数组:Array,是有序的元素序列,数组是在内存中开辟一段连续的空间,并在此空间存放元素。就像是一排出租屋,有100个房间,从001到100每个房间都有固定编号,通过编号就可以快速找到租房子的人。
简单的说,采用该结构的集合,对元素的存取有如下的特点:
查找元素快:通过索引,可以快速访问指定位置的元素
增删元素慢
指定索引位置增加元素:需要创建一个新数组,将指定新元素存储在指定索引位置,再把原数组元素根据索引,复制到新数组对应索引的位置。如下图
**指定索引位置删除元素:**需要创建一个新数组,把原数组元素根据索引,
复制到新数组对应索引的位置,原数组中指定索引位置元素不复制到新数组中。如下图
链表
链表:linked list,由一系列结点node(链表中每一个元素称为结点)组成,结点可以在运行时tao动态生成。每个结点包括两个部分:
一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。我们常说的链表结构有单向链表与双向链表,那么这里给大家介绍的是单向链表。
简单的说,采用该结构的集合,对元素的存取有如下的特点:
多个结点之间,通过地址进行连接。例如,多个人手拉手,每个人使用自己的右手拉住下个人的左手,依次类推,这样多个人就连在一起了。
查找元素慢:想查找某个元素,需要通过连接的节点,依次向后查找指定元素
增删元素快:
增加元素:只需要修改连接下个元素的地址即可。
删除元素:只需要修改连接下个元素的地址即可。
红黑树
二叉树:binary tree ,是每个结点不超过2的有序树(tree)
简单的理解,就是一种类似于我们生活中树的结构,只不过每个结点上都最多只能有两个子结点。
二叉树是每个节点最多有两个子树的树结构。顶上的叫根结点,两边被称作“左子树”和“右子树”。
如图:
我们要说的是二叉树的一种比较有意思的叫做红黑树,红黑树本身就是一颗二叉查找树,将节点插入后,该树仍然是一颗二叉查找树。也就意味着,树的键值仍然是有序的。
红黑树的约束:
节点可以是红色的或者黑色的
根节点是黑色的
叶子节点(特指空节点)是黑色的
每个红色节点的子节点都是黑色的
任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同
红黑树的特点:
- 速度特别快,趋近平衡树
- 查找叶子元素最少和最多次数不多于二倍
List集合
我们掌握了Collection接口的使用后,再来看看Collection接口中的子类,他们都具备那些特性呢?
接下来,我们一起学习Collection中的常用几个子类(java.util.List
集合、java.util.Set
集合)。
List接口介绍
java.util.List
接口继承自Collection
接口,是单列集合的一个重要分支,习惯性地会将实现了List
接口的对象称为List集合。在List集合中允许出现重复的元素,所有的元素是以一种线性方式进行存储的,在程序中可以通过索引来访问集合中的指定元素。另外,List集合还有一个特点就是元素有序,即元素的存入顺序和取出顺序一致。
看完API,我们总结一下:
List接口特点:
- 它是一个元素存取有序的集合。例如,存元素的顺序是11、22、33。那么集合中,元素的存储就是按照11、22、33的顺序完成的)。
- 它是一个带有索引的集合,通过索引就可以精确的操作集合中的元素(与数组的索引是一个道理)。
- 集合中可以有重复的元素,通过元素的equals方法,来比较是否为重复的元素。
java.util.ArrayList
类中的方法都是来自List中定义。
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 tao = 0;i<list.size();i++){System.out.println(list.get(tao));}//还可以使用增强forfor (String string : list) {System.out.println(string);} }
}
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);}
}
Set接口
java.util.Set
接口和java.util.List
接口一样,同样继承自Collection
接口,它与Collection
接口中的方法基本一致,并没有对Collection
接口进行功能上的扩充,只是比Collection
接口更加严格了。与List
接口不同的是,Set
接口中元素无序,并且都会以某种规则保证存入的元素不出现重复。
Set
集合有多个子类,这里我们介绍其中的java.util.HashSet
、java.util.LinkedHashSet
这两个集合。
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
根据结果我们发现字符串"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集合中的对象唯一
创建自定义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;}@Overridepublic 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);}@Overridepublic 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 2121int 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;}
}
上述add方法在同一个类中,只能存在一个。因为会发生调用的不确定性
注意:如果在方法书写时,这个方法拥有多参数,参数中包含可变参数,可变参数一定要写在参数列表的末尾位置。
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,返回(负数),相等返回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>() {@Overridepublic int compare(String o1, String o2) {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提供排序。
扩展
如果在使用的时候,想要独立的定义规则去使用 可以采用Collections.sort(List list,Comparetor<T> c)
方式,自己定义规则:
Collections.sort(list, new Comparator<Student>() {@Overridepublic int compare(Student o1, Student o2) {return o2.getAge()-o1.getAge();//以学生的年龄降序}
});
效果:
Student{name='rose', age=18}
Student{name='ace', age=17}
Student{name='jack', age=16}
Student{name='abc', age=16}
Student{name='mark', age=16}
如果想要规则更多一些,可以参考下面代码:
Collections.sort(list, new Comparator<Student>() {@Overridepublic 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;}});
效果如下:
Student{name='rose', age=18}
Student{name='ace', age=17}
Student{name='abc', age=16}
Student{name='jack', age=16}
Student{name='mark', age=16}
Map集合
概述
现实生活中,我们常会看到这样的一种集合:IP地址与主机名,身份证号与个人,系统用户名与系统用户对象等,这种一一对应的关系,就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象,即java.util.Map
接口。
我们通过查看Map
接口描述,发现Map
接口下的集合与Collection
接口下的集合,它们存储数据的形式不同,如下图。
Collection
中的集合,元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储。Map
中的集合,元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成,通过键可以找对所对应的值。Collection
中的集合称为单列集合,Map
中的集合称为双列集合。- 需要注意的是,
Map
中的集合不能包含重复的键,值可以重复;每个键只能对应一个值。
Map常用子类
通过查看Map接口描述,看到Map有多个子类,这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。
HashMap<K,V>
:存储数据采用的哈希表结构,元素的存取顺序不能保证一致。由于要保证键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。LinkedHashMap<K,V>
:HashMap下有个子类LinkedHashMap,存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致;通过哈希表结构可以保证的键的唯一、不重复,需要重写键的hashCode()
方法、equals()
方法。
tips:Map接口中的集合都有两个泛型变量<K,V>,在使用时,要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同,也可以不同。
Map接口中的常用方法
Map接口中定义了很多方法,常用的如下:
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集合)。
Map接口的方法演示
public class MapDemo {public static void main(String[] args) {//创建 map对象HashMap<String, String> map = new HashMap<String, String>();//添加元素到集合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("邓超")); }
}
使用put方法时,若指定的键(key)在集合中没有,则没有这个键对应的值,返回null,并把指定的键值添加到集合中;
若指定的键(key)在集合中存在,则返回值为集合中键对应的值(该值为替换前的值),并把指定键所对应的值,替换成指定的新值。
Map集合遍历键找值方式
键找值方式:即通过元素中的键,获取键所对应的值
分析步骤:
- 获取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);} }
}
遍历图解:
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集合)。
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对象 entrySetSet<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);}}
}
遍历图解:
tips:Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。
HashMap存储自定义类型键值
练习:每位学生(姓名,年龄)都有自己的家庭住址。那么,既然有对应关系,则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。
注意,学生姓名相同并且年龄相同视为同一名学生。
编写学生类:
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;}@Overridepublic 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);}@Overridepublic int hashCode() {return Objects.hash(name, age);}
}
编写测试类:
public class HashMapTest {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){Stringvalue = map.get(key);System.out.println(key.toString()+"....."+value);}}
}
- 当给HashMap中存放自定义对象时,如果自定义对象作为key存在,这时要保证对象唯一,必须复写对象的hashCode和equals方法(如果忘记,请回顾HashSet存放自定义对象)。
- 如果要保证map中存放的key和取出的顺序一致,可以使用
java.util.LinkedHashMap
集合来存放。
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());}}
}
结果:
邓超 孙俪
李晨 范冰冰
刘德华 朱丽倩
补充知识点
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); }
}
需要注意以下两点:
1:of()方法只是Map,List,Set这三个接口的静态方法,其父类接口和子类实现并没有这类方法,比如 HashSet,ArrayList等待;
2:返回的集合是不可变的;
泛型
如何存储基本数据类型
ArrayList对象不能存储基本类型,只能存储引用类型的数据。类似 不能写,但是存储基本数据类型对应的包装类型是可以的。所以,想要存储基本类型数据,<> 中的数据类型,必须转换后才能编写,转换写法如下:
基本类型 | 基本类型包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolen | Boolen |
泛型概述
在前面学习集合时,我们都知道集合中是可以存放任意对象的,只要把对象存储集合后,那么这时他们都会被提升成Object类型。当我们在取出每一个对象,并且进行相应的操作,这时必须采用类型转换。
大家观察下面代码:
public class GenericDemo {public static void main(String[] args) {Collection coll = new ArrayList();coll.add("abc");coll.add("tao");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只存储同一类型对象。例如都是存储字符串对象。因此在JDK5之后,新增了泛型(Generic)语法,让你在设计API时可以指定类或方法支持泛型,这样我们使用API的时候也变得更为简洁,并得到了编译时期的语法检查。
- 泛型:可以在类或方法中预支地使用未知的类型。
tips:一般在创建对象时,将未知的类型确定具体的类型。当没有指定泛型时,默认类型为Object类型。
使用泛型的好处
- 将运行时期的ClassCastException,转移到了编译时期变成了编译失败。
- 避免了类型强转的麻烦。
通过我们如下代码体验一下:
public class GenericDemo2 {public static void main(String[] args) {Collection<String> list = new ArrayList<String>();list.add("abc");list.add("tao");// list.add(5);//当集合明确类型后,存放类型不一致就会编译报错// 集合已经明确具体存放的元素类型,那么在使用迭代器的时候,迭代器也同样会知道具体遍历元素类型Iterator<String> it = list.iterator();while(it.hasNext()){String str = it.next();//当使用Iterator<String>控制元素类型后,就不需要强转了。获取到的元素直接就是String类型System.out.println(str.length());}}
}
tips:泛型是数据类型的一部分,我们将类名与泛型合并一起看做数据类型。
泛型的定义与使用
我们在集合中会大量使用到泛型,这里来完整地学习泛型知识。
泛型,用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。
定义和使用含有泛型的类
定义格式:
修饰符 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){ }...
}
再例如,ArrayList<Integer> list = new ArrayList<Integer>();
此时,变量E的值就是Integer类型,那么我们的类型就可以理解为:
class ArrayList<Integer> { public boolean add(Integer e) { }public Integer get(int index) { }...
}
举例自定义泛型类
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>(); // 调用setMVPmy.setMVP("大胡子登登");// 调用getMVPString 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;}
}
使用格式:调用方法时,确定泛型的类型
public class GenericMethodDemo {public static void main(String[] args) {// 创建对象MyGenericMethod mm = new MyGenericMethod();// 演示看方法提示mm.show("aaa");mm.show(123);mm.show(12.45);}
}
含有泛型的接口
定义格式:
修饰符 interface接口名<代表泛型的变量> { }
例如,
public interface MyGenericInterface<E>{public abstract void add(E e);public abstract E getE();
}
使用格式:
1、定义类时确定泛型的类型
例如
public class MyImp1 implements MyGenericInterface<String> {@Overridepublic void add(String e) {// 省略...}@Overridepublic String getE() {return null;}
}
此时,泛型E的值就是String类型。
2、始终不确定泛型的类型,直到创建对象时,确定泛型的类型
例如
public class MyImp2<E> implements MyGenericInterface<E> {@Overridepublic void add(E e) {// 省略...}@Overridepublic E getE() {return null;}
}
确定泛型:
/** 使用*/
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){}
//?代表可以接收任意类型
tips:泛型不存在继承关系 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){}
常用算法
遍试(穷举,exhaust algorithm)
在有限的范围内,可以对所有的值都进行试验和判断,从而找到满足条件的值
遍历算法的基本模式
for(;;){if();
}
迭代(iterative algorithm)
多次利用同一公式进行计算,每次将计算的结果再带入公式进行计算,从而逐步逼近精确解
迭代的基本模式
while(){x=f(x);
}
递归(recursive)
在递归调用中,一个过程执行的某一步要用到它的上一步(或上几步)的结果
递归算法的基本模式
f(n){f(n-1);
}
回溯(back-track)
先选择某一可能的线索进行试探,每一步试探都有多种方式,将每一方式都一一试探,如果不符合条件就返回纠正,反复进行这种试探再返回纠正,直到得出全部符合条件的答案或是问题无解为止。
回溯法的基本模式
x++;
if(…) {x--
}
Java学习笔记Day06 工具类及常用算法相关推荐
- java工具类应该抛异常吗,java学习阶段一 工具类(异常)
java学习阶段一 工具类(异常) 介绍 异常:运行期间出现的错误 背离程序本身意图的表现 基本知识 异常的分类 根类 Throwable Error 程序无法处理的错误 表示运行应用程序中教严重的问 ...
- java学习笔记7--抽象类与抽象方法
接着前面的学习: java学习笔记6--类的继承.Object类 java学习笔记5--类的方法 java学习笔记4--类与对象的基本概念(2) java学习笔记3--类与对象的基本概念(1) jav ...
- 第21天学习Java的笔记-数学工具类Arrays,Math
27天! 数学工具类 1.1数组工具类Arrays package Demo2101;/* 注意事项:是Arrays进行调用,不是变量进行调用!!!* java.util.Arrays是一个与数组相关 ...
- java学习笔记(13) 第13章 - 常用类
第13 章常用类-目录 13.1 包装类 13.1.1 包装类的分类.包装类和基本数据的转换.案例演示.课堂测试 13.1.2 包装类型和String 类型的相互转换 13.1.3 Integer 类 ...
- JAVA学习6-集合工具类、流
51.Collections集合工具类 除了重写compareTo方法比较TreeSet元素之外,还可以用比较器方式: 比较器实现java.util.comparator接口(Comparable是j ...
- Java学习笔记day7——枚举类练习、包装类、抽象类、接口
1. 枚举类的常用方法 (1)String name():返回枚举常量对象名称 (2)int ordinal():返回常量对象的下标 (3)String toString():Enum父类又重写了Ob ...
- java学习笔记(十)----String类和StringBuffer类
***String类和StringBuffer类 -------------------------- String类对象中的内容一旦被初始化就不能再改变 StringBuffer类用于封装内容可以改 ...
- Google Guava学习笔记——基础工具类Joiner的使用
Guava 中有一些基础的工具类,如下所列: 1,Joiner 类:根据给定的分隔符把字符串连接到一起.MapJoiner 执行相同的操作,但是针对 Map 的 key 和 value. 2,Spli ...
- OpenCV 3 Tracking API目标跟踪学习笔记——定义、物体跟踪常用算法、demo
今天开始接触目标跟踪 本文翻译自https://www.learnopencv.com/object-tracking-using-opencv-cpp-python/#opencv-tracking ...
最新文章
- Android巩固之事件分发机制
- php5.2通过saprfc扩展远程连接sap730成功案例
- PHP用单例模式实现一个数据库类
- 在Spring项目中集成使用MongoDB
- 前端和后端怎么进行数据交互的_前端VS后端
- maven tomcat插件_Maven技术01
- Java 7 最快要到 2012 年中发布
- 西门子主程序调用子程序_西门子PLC调用子程序的方法
- MCU OTA升级流程
- python怎么安装scrapy_Python-2.7安装Scrapy 1.0爬虫实例
- *ST东方A:山重水复疑无路 强烈推荐评级
- 多元线性回归公式推导及R语言实现
- SpringBoot2.x(三)热部署devtool和配置文件自动注入实战
- 如何在execl表格中打对勾和叉叉?
- APP推广骗局173人上当被骗200余万元
- 【BYM】Android 仿百度搜索列表滑动效果,写的太详细了
- 目前约五分之一日常关护是在医院外进行,未来三年这一比例将进一步提高
- Android 使用MediaPlayer播放网络音频
- 基于聚类分析算法的数字化图书馆、图书馆管理系统
- 上海华腾软件系统有限公司怎么样