目录
### 3.4 StringBuilder、StringBuffer类
### 3.6 Date、 SimpleDateFormat 类
### 3.0 API概述
https://www.oracle.com/cn/java/technologies/java-se-api-doc.html
**如何使用API**
- 看类的描述
Random类是用于生成随机数的类
- 看构造方法
Random():无参构造方法
~~~java
Random r = new Random();
~~~- 看成员方法
public int nextInt(int n):产生的是一个[0,n)范围内的随机数
- 调用方法：
~~~
int number = r.nextInt(100);
~~~### 3.1 包装类
基本数据类型（值类型）：byte, short, int, long, float, double, char, boolean
包装类：将基本数据类型，用一个类进行了一层包装，可以按照引用类型进行使用。同时还提供了若干用来进行数据转换的操作。
包装类按照基本数据类型的包装功能，分为八种：
| 基本数据类型 | 包装类型 |
| ------------ | --------- |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
| char | Character |
数据的装箱与拆箱：
**装箱：**由基本数据类型，转型为包装类型
~~~java
int a = 10;
// 通过构造方法进行装箱
Integer i1 = new Integer(a);
// 通过valueOf方法进行装箱
Integer i2 = Integer.valueOf(a);
~~~**拆箱：**由包装类型，转型为基本数据类型
~~~java
Integer i = new Integer(10);
int a = i.intValue();
~~~在jdk1.5之后，装箱与拆箱都是自动完成的。
~~~java
Integer a = 10;
int b = new Integer(10);
~~~基本数据类型与字符串类型之间的相互转换：
基本数据类型转字符串：
~~~java
String s1 = a + "";
String s2 = String.valueOf(a);
String s3 = Integer.valueOf(a).toString();
~~~字符串类型转型基本数据类型：
~~~java
int b = Integer.valueOf("123");
int c = Integer.parseInt("123");
~~~### 3.2 object类
Object:是类层次结构的根类，所有的类都直接的或者间接的继承自该类，Object类是所有类的父类。
**toString()**
把一个对象转变成字符串，以便显示打印；
~~~java
package kaikeba.com;
public class Student {
private String name;
private int age;
public Student() {}
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 String toString() {
// return "Student [name=" + name + ", age=" + age + "]";
// }
}
class ObjectDemo {
public static void main(String[] args) {
Student s = new Student();
s.setName("孙俪");
s.setAge(30);
System.out.println(s);
System.out.println(s.toString());
}
}
~~~**equals()方法**
对象进行比较，比较的是对象的地址；
~~~java
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 + "]";
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
//比较的是对象是否是同一个类的对象
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj; //other -- s2
if (age != other.age) //this.age -- s1.age
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
//字符串的equals()比较的是字符串的内容是否相同
return false;
return true;
}
}
/*
* ==:
* 可以比较基本数据类型，比较基本数据类型的时候比较的是基本数据类型的值是否相同
* 也可以比较引用数据类型，比较引用数据类型的时候比较的是引用数据类型的地址值是否相同
*
* 而我们现在想比较的是对象的内容是否相同?该怎么办呢?
* 通过查看API，我们找到了比较对象是否相等的方法：
* public boolean equals(Object obj)
* Object类中的equals()方法默认比较的是对象的地址是否相同。
* 如果我们想比较对象的内容是否相同，就必须自己重写该方法。
* 如何重写该方法呢?
* 自动生成即可。
*/
public class ObjectDemo {
public static void main(String[] args) {
Student s1 = new Student("孙俪", 30);
Student s2 = new Student("孙俪", 30);
//System.out.println(s1 == s2);//false
System.out.println(s1.equals(s2));//false
/*
public boolean equals(Object obj) {
//this -- s1
//obj -- s2
return (this == obj);
}
*/
}
}
~~~### 3.3 String类
- "abc"是String类的一个实例,或者成为String类的一个对象
- 字符串字面值"abc"也可以看成是一个字符串对象
- 字符串是常量，一旦被赋值，就不能被改变
- 字符串本质是一个字符数组
**构造方法**
String(String original):把字符串数据封装成字符串对象
String(char[] value):把字符数组的数据封装成字符串对象
String(char[] value, int index, int count):把字符数组的一部分数据封装成字符串对象
~~~java
* String：代表字符串类。
* 由多个字符组成的一串数据。
* 字符串的本质就是一个字符数组。
*
* 构造方法：
* String(String original):把字符串数据封装成字符串对象
* String(char[] value):把字符数组的数据封装成字符串对象
* String(char[] value, int index, int count):把字符数组的一部分数据封装成字符串对象
*
* public String toString():返回此对象本身（它已经是一个字符串！）。
*/
public class StringDemo {
public static void main(String[] args) {
//String(String original):把字符串数据封装成字符串对象
String s1 = new String("hello");
System.out.println(s1);
System.out.println("----------");
//String(char[] value):把字符数组的数据封装成字符串对象
char[] value = {'h','e','l','l','o'};
String s2 = new String(value);
System.out.println(s2);
System.out.println("----------");
//String(char[] value, int index, int count):把字符数组的一部分数据封装成字符串对象
//String s3 = new String(value,0,value.length);
String s3 = new String(value,0,3);
System.out.println(s3);
System.out.println("----------");
//最常用的
String s4 = "hello";
System.out.println(s4);
}
}
~~~**常用方法：**
~~~java
boolean equals(Object obj) 判断两个字符串中的内容是否相同
boolean equalsIgnoreCase(String str) 判断两个字符串中的内容是否相同, 忽略大小写
boolean contains(String str) 判断该字符串中 是否包含给定的字符串
boolean startsWith(String str) 判断该字符串 是否以给定的字符串开头
boolean endsWith(String str) 判断该字符串 是否以给定的字符串结尾
boolean isEmpty() 判断该字符串的内容是否为空的字符串 ""
int length() 获取该字符串的长度
char charAt(int index) 获取该字符串中指定位置上的字符
String substring(int start) 从指定位置开始，到末尾结束，截取该字符串，返回新字符串
String substring(int start,int end) 从指定位置开始，到指定位置结束，截取该字符串，返回新字符串
int indexOf(int ch ) 获取给定的字符，在该字符串中第一次出现的位置
int indexOf(String str) 获取给定的字符串，在该字符串中第一次出现的位置
int indexOf(int ch,int fromIndex) 从指定位置开始，获取给定的字符，在该字符
byte[] getBytes() 把该字符串 转换成 字节数组
char[] toCharArray() 把该字符串 转换成 字符数组
String replace(char old,char new) 在该字符串中，将给定的旧字符，用新字符替换
String replace(String old,String new) 在该字符串中， 将给定的旧字符串，用新字符串替换
String trim() 去除字符串两端空格，中间的不会去除，返回一个新字符串
String toLowerCase() 把该字符串转换成 小写字符串
String toUpperCase() 把该字符串转换成 大写字符串
int indexOf(String str,int fromIndex) 从指定位置开始，获取给定的字符串，在该字符串中第一次出现的位置
~~~**字符串比较**
boolean equals(Object obj):比较字符串的内容是否相同
boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
~~~java
import java.util.Scanner;
/*
* 需求：模拟登录,给三次机会,并提示还有几次
* 分析：
* A:定义两个字符串对象，用于存储已经存在的用户名和密码
* B:键盘录入用户名和密码
* C:拿键盘录入的用户名和密码去跟已经存在的用户名和密码进行比较
* 如果内容相同，就提示登录成功
* 如果内容不同，就提示登录失败，并提示还有几次机会
* public boolean equals(Object anObject):比较字符串的内容，严格区分大小写(用户名和密码)
* public boolean equalsIgnoreCase(String anotherString):比较字符串的内容，不考虑大小写(验证码)
*/
public class StringTest {
public static void main(String[] args) {
//定义两个字符串对象，用于存储已经存在的用户名和密码
String username = "admin";
String password = "admin";
for(int x=0; x<3; x++) {
//键盘录入用户名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String name = sc.nextLine();
System.out.println("请输入密码：");
String pwd = sc.nextLine();
//拿键盘录入的用户名和密码去跟已经存在的用户名和密码进行比较
if(username.equals(name) && password.equals(pwd)) {
System.out.println("登录成功");
break;
}else {
if((2-x) == 0){
System.out.println("你的帐号被锁定，请与管理员联系");
}else {
System.out.println("登录失败，你还有"+(2-x)+"次机会");
}
}
}
}
}
~~~**字符串拼接**
~~~java
/*
* 需求：把数组中的数据按照指定个格式拼接成一个字符串
* 举例：int[] arr = {1,2,3};
* 输出结果：[1, 2, 3]
*
* 分析：
* A:定义一个int类型的数组
* B:写方法实现把数组中的元素按照指定的格式拼接成一个字符串
* C:调用方法
* D:输出结果
*/
public class StringTest3 {
public static void main(String[] args) {
//定义一个int类型的数组
int[] arr = {1,2,3};
//调用方法
String result = arrayToString(arr);
//输出结果
System.out.println("result:"+result);
}
public static String arrayToString(int[] arr) {
String s = "";
//[1, 2, 3]
s+="[";
for(int x=0; x<arr.length; x++) {
if(x==arr.length-1) {
s += arr[x];
}else {
s += arr[x];
s += ", ";
}
}
s+="]";
return s;
}
}
~~~**字符串反转**
~~~java
/*
* 需求：字符串反转
* 举例：键盘录入”abc”
* 输出结果：”cba”
*
* 分析：
* A:键盘录入字符串数据
* B:写方法实现字符串数据的反转
* 把字符串倒着遍历，在把每一个得到的字符拼接成一个字符串
* C:调用方法
* D:输出结果
*/
public class StringTest4 {
public static void main(String[] args) {
//键盘录入字符串数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String s = sc.nextLine();
//写方法实现字符串数据的反转
//调用方法
String result = reverse(s);
//输出结果
System.out.println("result:"+result);
}
public static String reverse(String s) {
//把字符串倒着遍历，在把每一个得到的字符拼接成一个字符串
String ss = "";
for(int x=s.length()-1; x>=0; x--) {
ss += s.charAt(x);
}
return ss;
}
}
~~~### 3.4 StringBuilder、StringBuffer类
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder:是一个可变的字符串。字符串缓冲区类。
String和StringBuilder的区别：
String的内容是固定的
StringBuilder的内容是可变的
- 构造方法
~~~java
public StringBuilder()
public StringBuilder(String str)
~~~- 成员方法:
~~~java
public StringBuffer append(String str) 在原有字符串缓冲区内容基础上，在末尾追加新数据
public StringBuffer insert(int offset,String str) 在原有字符串缓冲区内容基础上，在指定位置插入新数据
public StringBuffer deleteCharAt(int index) 在原有字符串缓冲区内容基础上，删除指定位置上的字符
public StringBuffer delete(int start,int end) 在原有字符串缓冲区内容基础上，删除指定范围内的多个字符
public StringBuffer replace(int start,int end,String str)在原有字符串缓冲区内容基础上，将指定范围内的多个字符 用给定的字符串替换
public StringBuffer reverse() 将字符串缓冲区的内容 反转 "abc"----"cba"
public String substring(int start) 从指定位置开始，到末尾结束，截取该字符串缓冲区，返回新字符串
public String substring(int start,int end) 从指定位置开始，到指定位置结束，截取该字符串缓冲区，返回新字符串
~~~- StringBuffer和StringBuilder：
StringBuffer是线程安全的，StringBuilder是线程不安全的。
StringBuilder的执行效率比StringBuffer高
~~~java
/*
* StringBuilder:是一个可变的字符串类。
*
* String和StringBuilder的区别：
* String的内容是固定的。
* StringBuilder的内容是可变的。
*
* 构造方法
* public StringBuilder()
* public StringBuilder(String str)
*
* public String toString():返回此序列中数据的字符串表示形式。
*/
public class StringBuilderDemo {
public static void main(String[] args) {
//public StringBuilder()
StringBuilder stringBuilder = new StringBuilder();
System.out.println("stringBuilder:"+stringBuilder);
System.out.println(stringBuilder.length());
System.out.println("----------------");
//public StringBuilder(String str)
StringBuilder stringBuilder2 = new StringBuilder("helloworld");
System.out.println("stringBuilder2:"+stringBuilder2);
System.out.println(stringBuilder2.length());
//添加功能
/*
stringBuilder.append("hello");
stringBuilder.append("world");
stringBuilder.append(true);
stringBuilder.append(100);
*/
//链式编程
stringBuilder.append("hello").append("world").append(true).append(100);
System.out.println("stringBuilder:"+stringBuilder);
//反转功能
//public StringBuilder reverse()
stringBuilder.reverse();
System.out.println("stringBuilder:"+stringBuilder);
}
}
~~~StringBuilder和String通过方法完成相互转换
~~~java
/*
* StringBuilder和String的相互转换
*
* StringBuilder -- String
* public String toString():通过toString()就可以实现把StringBuilder转换为String
*
* String -- StringBuilder
* public StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder
*/
public class StringBuilderTest {
public static void main(String[] args) {
//StringBuilder -- String
StringBuilder stringBuilder = new StringBuilder();
sb.append("hello");
//错误的
//String s = stringBuilder;
String s = sbstringBuildertoString();
System.out.println(s);
//String -- StringBuilder
String s = "hello";
StringBuilder stringBuilder = new StringBuilder(s);
System.out.println(stringBuilder);
}
}
~~~### 3.5 Arrays类
Arrays:提供了对数组操作的各种方法。需要注意，如果指定数组引用为 null，则访问此类中的方法都会抛出空指针异常NullPointerException。
~~~java
public static String toString(int[] a):把数组转成字符串
public static void sort(int[] a):对数组进行升序排序
~~~~~~java
import java.util.Arrays;
/*
* public static String toString(int[] a):把数组转成字符串
* public static void sort(int[] a):对数组进行升序排序
*/
public class ArraysDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = {24,69,80,57,13};
//public static String toString(int[] a):把数组转成字符串
System.out.println("排序前："+Arrays.toString(arr));
//public static void sort(int[] a):对数组进行升序排序
Arrays.sort(arr);
System.out.println("排序后："+Arrays.toString(arr));
}
}
~~~### 3.6 Date、 SimpleDateFormat 类
Date: 是用来表示一个时间、日期的类；
构造方法：
Date():根据当前时间创建的日期对象
Date(long date):根据给定的毫秒值创建对象，从1970 年 1 月 1 日 00:00:00
~~~java
/*
* Date:Date表示特定的瞬间，精确到毫秒。
* 构造方法：
* Date():根据当前时间创建的日期对象
* Date(long date):根据给定的毫秒值创建对象，从1970 年 1 月 1 日 00:00:00
*/
public class DateDemo {
public static void main(String[] args) {
//Date()
Date d = new Date();
System.out.println(d);
//Date(long date)
long date = 1000 * 60 * 60;
Date dd = new Date(date);
System.out.println(dd);
}
}
~~~| 常用方法 | 描述 |
| -------------------------- | ------------------------------ |
| Date() | 获取当前时间 |
| Date(long time) | 获取指定时间戳对应的时间 |
| void setTime(long time) | 使用指定时间戳设置一个日期对象 |
| long getTime() | 获取一个指定日期对象的时间戳 |
| equals(Object obj) | 判断是否与另外一个日期相同 |
| boolean before(Date other) | 判断是否在另外一个日期之前 |
| boolean after(Date other) | 判断是否在另外一个日期之后 |
~~~java
public long getTime():获取的是毫秒值。从1970年1月1日 00:00:00开始的。
public void setTime(long time):设置时间，给的是毫秒值。
~~~案例：
~~~java
import java.util.Date;
/*
* public long getTime():获取的是毫秒值。从1970年1月1日 00:00:00开始的。
* public void setTime(long time):设置时间，给的是毫秒值。
*
* 从Date得到一个毫秒值：
* getTime()
*
* 从一个毫秒值得到一个Date对象
* 构造方法
* setTime(long time)
*/
public class DateDemo2 {
public static void main(String[] args) {
//创建对象
Date d = new Date();
//public long getTime()
System.out.println(d.getTime());
//public void setTime(long time)
d.setTime(1000*60*60);
System.out.println(d.getTime());
}
}
~~~SimpleDateFormat:是一个格式化和解析日期的具体类。
它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）
格式化（日期 -> 文本）: Date -- String，将一个Date格式化为指定格式的字符串
public final String format(Date date)
解析（文本 -> 日期）: String -- Date，将一个自定格式的字符串解析为一个Date
public Date parse(String source)
yyyy: 年
yy: 年（短）
MM: 月
dd: 日
HH: 时（24小时制）
hh: 时（12小时制）
mm: 分
ss: 秒
| 常用方法 | 描述 |
| -------------------------------- | ------------------------------------ |
| SimpleDateFormat(String pattern) | 使用指定的格式来实例化一个对象 |
| String format(Date date) | 将一个日期格式化为指定的字符串 |
| Date parse(String str) | 将一个指定格式的字符串解析为一个日期 |
~~~java
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
* SimpleDateFormat:是一个以与语言环境有关的方式来格式化和解析日期的具体类。
* 它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）
*
* 格式化（日期 -> 文本）: Date -- String
* public final String format(Date date)
*
* 解析（文本 -> 日期）: String -- Date
* public Date parse(String source)
*/
public class SimpleDateFormatDemo {
public static void main(String[] args) throws ParseException {
//Date -- String
Date d = new Date();
//用默认的模式
//SimpleDateFormat sdf = new SimpleDateFormat();
//用给定的模式
//SimpleDateFormat(String pattern)
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String s = sdf.format(d);
//现在虽然实现了把日期格式化成一个字符串，但是不是我们想要的格式
//我们想要的格式是：xxxx年xx月xx日 xx:xx:xx
System.out.println(s);
//String -- Date
String str = "2000-08-08 12:12:12";
//把一个字符串解析为日期的时候，请注意模式字符串和给定的日期字符串的格式要匹配
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf.parse(str);
System.out.println(d);
}
}
~~~### 3.7 集合
所有的集合框架都包含如下内容：
- 接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
- 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
- 算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。
除了集合，还定义了几个 Map 接口和类。Map 里存储的是键/值对。尽管 Map 不是集合，但是它们完全整合在集合中。
#### 3.7.1 **Set**
Set:元素唯一,存储元素无序,一个不包含重复元素的 collection
#### 3.7.2 HashSet
HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。
HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取和查找性能。
HashSet 具有以下特点：
不能保证元素的排列顺序,HashSet 不是线程安全的,集合元素可以是 null；
当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值决定该对象在 HashSet 中的存储位置。
HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。
如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。
对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。存储JavaAPI中提供的类型元素时，不需要重写元素的hashCode和equals方法。
~~~java
public class HashSetDemo {
public static void main(String[] args) {
//创建HashSet对象
HashSet<String> hs = new HashSet<String>();
//给集合中添加自定义对象
hs.add("zhangsan");
hs.add("lisi");
hs.add("wangwu");
hs.add("zhangsan");
//取出集合中的每个元素
Iterator<String> it = hs.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
}
~~~自定义类型的存储：
重写 hashCode() 方法的基本原则:
在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值；
当两个对象的 equals() 方法比较返回 true 时，这两个对象的 hashCode() 方法的返回值也应相等;
对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值;
~~~java
class Student {
private String name;
private int age;
public Student(String name, int age) {
super();
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 hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if(!(obj instanceof Student)){
System.out.println("类型错误");
return false;
}
Student other = (Student) obj;
return this.age == other.age && this.name.equals(other.name);
}
}
public class HashSetDemo {
public static void main(String[] args) {
//创建HashSet对象
HashSet hs = new HashSet();
//给集合中添加自定义对象
hs.add(new Student("zhangsan",21));
hs.add(new Student("lisi",22));
hs.add(new Student("wangwu",23));
hs.add(new Student("zhangsan",21));
//取出集合中的每个元素
Iterator it = hs.iterator();
while(it.hasNext()){
Student s = (Student)it.next();
System.out.println(s);
}
}
}
~~~#### 3.7.3 Map
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
Map 中的 key 和 value 都可以是任何引用类型的数据
Map 中的 key 不允许重复
常用String类作为Map的“键”。
key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value。
~~~java
V put(K key,V value):添加元素
V remove(Object key):根据键删除键值对元素
void clear():移除所有的键值对元素
boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
int size()：返回集合中的键值对的对数
~~~#### 3.7.4 HashMap
Map接口的常用实现类：HashMap、TreeMap和Properties。
HashMap是 Map 接口使用频率最高的实现类。
允许使用null键和null值，与HashSet一样，不保证映射的顺序。
HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true，hashCode 值也相等。
HashMap 判断两个 value相等的标准是：两个 value 通过 equals() 方法返回 true。
~~~java
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;
}
}
public class HashMapTest {
public static void main(String[] args) {
// 创建集合对象
HashMap<String, Student> hm = new HashMap<String, Student>();
// 创建元素对象
Student s1 = new Student("丽丽", 30);
Student s2 = new Student("冰冰", 35);
Student s3 = new Student("敏敏", 33);
// 添加元素到集合中
hm.put("it001", s1);
hm.put("it002", s2);
hm.put("it003", s3);
// 遍历
// 根据键找值
Set<String> set = hm.keySet();
for (String key : set) {
Student value = hm.get(key);
System.out.println(key + "---" + value.getName() + "---" + value.getAge());
}
System.out.println("---------------------");
// 根据键值对对象找键和值
Set<Map.Entry<String, Student>> set2 = hm.entrySet();
for (Map.Entry<String, Student> me : set2) {
String key = me.getKey();
Student value = me.getValue();
System.out.println(key + "---" + value.getName() + "---" + value.getAge());
}
}
}
~~~#### 3.7.5 List
List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。
~~~java
//增加元素方法
add(Object e)：向集合末尾处，添加指定的元素
add(int index, Object e)：向集合指定索引处，添加指定的元素，原有元素依次后移
//删除元素删除
remove(Object e)：将指定元素对象，从集合中删除，返回值为被删除的元素
remove(int index)：将指定索引处的元素，从集合中删除，返回值为被删除的元素
//替换元素方法
set(int index, Object e)：将指定索引处的元素，替换成指定的元素，返回值为替换前的元素
//查询元素方法
get(int index)：获取指定索引处的元素，并返回该元素
~~~#### 3.7.6 ArrayList
ArrayList 是 List 接口的典型实现类
本质上，ArrayList是对象引用的一个变长数组
ArrayList 是线程不安全的，而 Vector 是线程安全的，即使为保证 List 集合线程安全，也不推荐使用Vector
Arrays.asList(…) 方法返回的 List 集合既不是 ArrayList 实例，也不是 Vector 实例。 Arrays.asList(…) 返回值是一个固定长度的 List 集合
ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
~~~java
public class ArrayListDemo {
//在list集合迭代元素中，对元素进行判断，一旦条件满足就添加一个新元素
public static void main(String[] args) {
//创建List集合
List<String> list = new ArrayList<String>();
//给集合中添加元素
list.add("ab");
list.add("cd");
list.add("ef");
list.add("g");
//遍历集合
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = it.next();
//判断取出的元素是否是"g"，是就添加一个新元素
if("g".equals(str)){
list.add("hi");// 该操作会导致程序出错
//在迭代时，不要使用集合的方法操作元素
}
}
//打印容器中的元素
System.out.println(list);
}
}
~~~#### 3.7.7 LinkedList
对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高
~~~java
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList<String> link = new LinkedList<String>();
//添加元素
link.addFirst("ab");
link.addFirst("cd");
link.addFirst("ef");
//获取元素
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()); //弹出集合中的栈顶元素
}
}
}
~~~#### 3.7.8 collections
Collections 是一个操作 Set、List 和 Map 等集合的工具类
Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
~~~java
//排序操作：（均为static方法）
reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
~~~相关文章：
javaSE（1）基础语法
javaSE（2）面向对象
javaSE（4）异常
javaSE（5）IO流
javaSE（6）多线程
javaSE（7）网络编程