主要内容：
1.1什么是集合
1.2List
1.3Set
1.4Map
1.1什么是集合
集合就是用来保存、盛装其他数据，也就是为了保存数量不确定的数据以及具有映射关系的数据（关联数组），Java所有的集合都在java.util包下面，集合现在主要分为两大体系（collection体系和map体系），collection和Map是两大体系的顶层接口。
collection体系有三个子接口，分别是：List（列表）、Set（集）、Queue（队列）
注意：
集合只能存放对象，
集合存放的都是对象的引用，并不是对象本身
集合可以放不同类型不限数量的数据类型
1.2List
List是一个元素有序并且可以重复的集合，可以精确控制每一个元素的插入位置，可以通过索引访问元素。
1.2.1ArrayListArraylist相当于一个动态数组，它的容量能够动态增长，存在其中的数据被称为元素，它提供了快速基于索引访问元素的方式，使用 ArrayList 创建的集合，允许对集合中的元素进行快速的随机访问，此外向 ArrayList 中插入与删除元素的速度相对较慢。
ArrayList方法;
E get(int index);//返回集合index索引处的对象； int indexOf(Object o);//返回对象o在List集合中第一次出现的位置索引； int lastIndexOf(Object o);//返回对象o在List集合中最后一次出现的位置索引； E set(int index, E element);//将index索引处的元素替换为新的element对象，并返回被替换的旧元素； ListsubList(int fromIndex, int toIndex);//返回从索引fromIndex（包含）到索引toIndex（不包含）所有元素组成的子集合；
运用实例
public static void main(String[] args) {
List list = new ArrayList();
list.add("One");
list.add("|");
list.add("Two");
list.add("|");
list.add("Three");
list.add("|");
list.add("Four");
System.out.println("list 集合中的元素数量：" + list.size());
System.out.println("list 集合中的元素如下：");
Iterator it = list.iterator();
while (it.hasNext()) {
System.out.print(it.next() + "、");
}
System.out.println("n在 list 集合中'丨'第一次出现的位置是：" + list.indexOf("|"));
System.out.println("在 list 集合中'丨'最后一次出现的位置是：" + list.lastIndexOf("|"));
}
1.2.2LinkedList
LinkedList 是采用链表结构保存对象，便于向集合中插入或者删除元素，需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高，但是 LinkedList 类随机访问元素的速度则相对较慢。这里的随机访问是指检索集合中特定索引位置的元素
LinkedList方法;
void addFirst(E e) //将指定元素添加到此集合的开头 void addLast(E e) //将指定元素添加到此集合的末尾 E getFirst() //返回此集合的第一个元素 E getLast() //返回此集合的最后一个元素 E removeFirst() //删除此集合中的第一个元素 E removeLast() //删除此集合中的最后一个元素
运用实例
public class Test {
public static void main(String[] args) {
LinkedList products = new LinkedList(); // 创建集合对象
String p1 = new String("六角螺母");
String p2 = new String("10A 电缆线");
String p3 = new String("5M 卷尺");
String p4 = new String("4CM 原木方板");
products.add(p1); // 将 p1 对象添加到 LinkedList 集合中
products.add(p2); // 将 p2 对象添加到 LinkedList 集合中
products.add(p3); // 将 p3 对象添加到 LinkedList 集合中
products.add(p4); // 将 p4 对象添加到 LinkedList 集合中
String p5 = new String("标准文件夹小柜");
products.addLast(p5); // 向集合的末尾添加p5对象
System.out.print("*************** 商品信息 ***************");
System.out.println("n目前商品有：");
for (int i = 0; i < products.size(); i++) {
System.out.print(products.get(i) + "t");
}
System.out.println("n第一个商品的名称为：" + products.getFirst());
System.out.println("最后一个商品的名称为：" + products.getLast());
products.removeLast(); // 删除最后一个元素
System.out.println("删除最后的元素，目前商品有：");
for (int i = 0; i < products.size(); i++) {
System.out.print(products.get(i) + "t");
}
}
}
1.3set
set继承于collection的接口，它不会出现重复的元素，它所存放的元素都是无序的，主要有HashSet和TreeSet两个实现类，最多只允许包含一个 null 元素。
1.3.1HashSetHashSet 是按照 Hash 算法来存储集合中的元素，具有很好的存取和查找性能。Hashset不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。HashSet 不是同步的，集合元素值可以是 null。
当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象hashCode() 方法来得到该对象的 hashCode 值，然后根据该 hashCode 值决定该对象在 HashSet 中的存储位置。两个对象的 hashCode 值相等且通过 equals() 方法比较返回结果为 true，则 HashSet 集合认为两个元素相等，如果有两个元素通过 equals() 方法比较返回的结果为 true，但它们的 hashCode 不相等，HashSet 将会把它们存储在不同的位置。
创建两种不同形式的 HashSet 对象的方式：
HashSet hs = new HashSet(); // 调用无参的构造函数创建HashSet对象 HashSethss = new HashSet (); // 创建泛型的 HashSet 集合对象
public static void main(String[] args) {
HashSet courseSet = new HashSet(); // 创建一个空的 Set 集合
String course1 = new String("Java入门教程");
String course2 = new String("Python基础教程");
String course3 = new String("C语言学习教程");
String course4 = new String("Golang入门教程");
courseSet.add(course1); // 将 course1 存储到 Set 集合中
courseSet.add(course2); // 将 course2 存储到 Set 集合中
courseSet.add(course3); // 将 course3 存储到 Set 集合中
courseSet.add(course4); // 将 course4 存储到 Set 集合中
System.out.println("C语言中文网教程有：");
Iterator it = courseSet.iterator();
while (it.hasNext()) {
System.out.println("《" + (String) it.next() + "》"); // 输出 Set 集合中的元素
}
System.out.println("有" + courseSet.size() + "套精彩教程！");
}
1.3.2TreeSet
TreeSet 类同时实现了 Set 接口和 SortedSet 接口。SortedSet 接口是 Set 接口的子接口，可以实现对集合进行自然排序，因此使用 TreeSet 类实现的Set 接口默认情况下是自然排序的，这里的自然排序指的是升序排序。TreeSet 只能对实现了 Comparable 接口的类对象进行排序
TreeSet中的方法
E first() 返回此集合中的第一个元素。其中，E 表示集合中元素的数据类型 E first() 返回此集合中的第一个元素。其中，E 表示集合中元素的数据类型 E poolLast() 获取并移除此集合中的最后一个元素 SortedSetsubSet(E fromElement,E toElement) 返回一个新的集合，新集合包含原集合中 fromElement 对象与 toElement 对象之间的所有对象。包含 fromElement 对象，不包含 toElement 对象 SortedSet headSet tailSet(E fromElement) 返回一个新的集合，新集合包含原集合中 fromElement 对象之后的所有对象。包含 fromElement 对象
运用实例：
public class Test08 {
public static void main(String[] args) {
TreeSet scores = new TreeSet(); // 创建 TreeSet 集合
Scanner input = new Scanner(System.in);
System.out.println("------------学生成绩管理系统-------------");
for (int i = 0; i < 5; i++) {
System.out.println("第" + (i + 1) + "个学生成绩：");
double score = input.nextDouble();
// 将学生成绩转换为Double类型，添加到TreeSet集合中
scores.add(Double.valueOf(score));
}
Iterator it = scores.iterator(); // 创建 Iterator 对象
System.out.println("学生成绩从低到高的排序为：");
while (it.hasNext()) {
System.out.print(it.next() + "t");
}
System.out.println("n请输入要查询的成绩：");
double searchScore = input.nextDouble();
if (scores.contains(searchScore)) {
System.out.println("成绩为： " + searchScore + " 的学生存在！");
} else {
System.out.println("成绩为： " + searchScore + " 的学生不存在！");
}
// 查询不及格的学生成绩
SortedSet score1 = scores.headSet(60.0);
System.out.println("n不及格的成绩有：");
for (int i = 0; i < score1.toArray().length; i++) {
System.out.print(score1.toArray()[i] + "t");
}
// 查询90分以上的学生成绩
SortedSet score2 = scores.tailSet(90.0);
System.out.println("n90 分以上的成绩有：");
for (int i = 0; i < score2.toArray().length; i++) {
System.out.print(score2.toArray()[i] + "t");
}
}
}
1.4Map
Map 是一种键-值对（key-value）集合，Map 集合中的每一个元素都包含一个键（key）对象和一个值（value）对象。用于保存具有映射关系的数据。Map 集合里保存着两组值，一组值用于保存 Map 里的 key，另外一组值用于保存 Map 里的 value，key 和 value 都可以是任何引用类型的数据。Map 的 key 不允许重复，value 可以重复，通过指定的 key，总能找到唯一的、确定的 value。
Map 接口主要有两个实现类：HashMap 类和 TreeMap 类。其中，HashMap 类按哈希算法来存取键对象，而 TreeMap 类可以对键对象进行排序。
Map中的方法：
oid clear()//删除该 Map 对象中的所有 key-value 对。 boolean containsKey(Object key)//查询 Map 中是否包含指定的 key，如果包含则返回 true。 boolean containsValue(Object value)//查询 Map 中是否包含一个或多个 value，如果包含则返回 true。 V get(Object key)//返回 Map 集合中指定键对象所对应的值。V 表示值的数据类型 V put(K key, V value)//向 Map 集合中添加键-值对，如果当前 Map 中已有一个与该 key 相等的 key-value 对，则新的 key-value 对会覆盖原来的 key-value 对。 void putAll(Map m)//将指定 Map 中的 key-value 对复制到本 Map 中。 V remove(Object key)//从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如果该 key 不存在，则返回 null boolean remove(Object key, Object value)//这是 Java 8 新增的方法，删除指定 key、value 所对应的 key-value 对。如果从该 Map 中成功地删除该 key-value 对，该方法返回 true，否则返回 false。 Set entrySet()//返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据类型为 Map.Entry Set keySet()//返回 Map 集合中所有键对象的 Set 集合 boolean isEmpty()//查询该 Map 是否为空（即不包含任何 key-value 对），如果为空则返回 true。 int size()//返回该 Map 里 key-value 对的个数 Collection values()//返回该 Map 里所有 value 组成的 Collection
运用实例：
public class Test09 {
public static void main(String[] args) {
HashMap users = new HashMap();
users.put("11", "张浩太"); // 将学生信息键值对存储到Map中
users.put("22", "刘思诚");
users.put("33", "王强文");
users.put("44", "李国量");
users.put("55", "王路路");
System.out.println("******** 学生列表 ********");
Iterator it = users.keySet().iterator();
while (it.hasNext()) {
// 遍历 Map
Object key = it.next();
Object val = users.get(key);
System.out.println("学号：" + key + "，姓名:" + val);
}
Scanner input = new Scanner(System.in);
System.out.println("请输入要删除的学号：");
int num = input.nextInt();
if (users.containsKey(String.valueOf(num))) { // 判断是否包含指定键
users.remove(String.valueOf(num)); // 如果包含就删除
} else {
System.out.println("该学生不存在！");
}
System.out.println("******** 学生列表 ********");
it = users.keySet().iterator();
while (it.hasNext()) {
Object key = it.next();
Object val = users.get(key);
System.out.println("学号：" + key + "，姓名：" + val);
}
}
}
二、常用类
主要内容：
2.1Object
2.2String
2.3StringBuilder
2.4StringBuffer
2.5System
2.6Data
2.7SimpleDateFormat
2.1Object
Object 类，它是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类就默认继承 Object 类。Java 中任何一个类都是它的子类。由于所有的类都是由 Object 类衍生出来的，所以 Object 类中的方法适用于所有类。
Object常用方法：
Object clone() 创建与该对象的类相同的新对象 boolean equals(Object) 比较两个对象是否相等。默认比较的是地址值。 void finalize() 当垃圾回收器确定不存在对该对象的更多引用时，对象的圾回收器调用该方法 Class getClass() 返回一个对象运行时的实例类（.class文件） int hashCode() 返回该对象的散列码值 void notify() 激活等待在该对象的监视器上的一个线程 void notifyAll() 激活等待在该对象的监视器上的全部线程 String toString() 返回该对象的字符串表示，默认返回运行时类名+@+对象的hashCode的16进制数 void wait() 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待
2.2String
表示的是字符串，字符串是常量
String中与字符集相关的方法
String(byte[] by,String charset):通过指定的字符集，将指定的字节数组转成字符串(解码)
byte[] getBytes(String charset):通过指定的字符集，将字符串转成字节数组（编码）
正则表达式的作用:约束字符串的格式
字符集:
[] :方括号表示其中的内容任选其一,代表一个字符 ： [1234] 1,2,3,4任选其一
() :表示一组内容,圆括号中可以使用"|"符号
| :逻辑或关系
^ :非,除了 例如 [^12] 除了1或2的其他字符
- :范围,范围应从小到大 ：
[0-9]表示此字符只能是数字
[a-f]表示此字符只能是a,b,c,d,e,f之一
[0-6a-fA-F] 0123456abcdefABCDEF
{n,m} :修饰前一个字符,表示其出现n-m次.n应小于m
{n} :修饰前一个字符,表示其出现n次
{n,} :修饰前一个字符,表示其出现n次以上
预定义字符集:
d :表示一个数字.与[0-9]意思一致
. :表示任意字符
w :表示单词字符.[0-9a-zA-Z_] 包含个下划线
s :表示空白: t n r b p
D :表示非数字
W :非单词字符
S :非空白
? :修饰前一个字符出现0-1次. {0,1}
- :修饰前一个字符出现1次以上.{1,}
- :修饰前一个字符出现任意次. {0,}
运用实例：
public class StringTest02 {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";
System.out.println(s3 == s1+s2); //false
System.out.println(s3.equals(s1+s2)); //true
System.out.println(s3 == "hello"+"world"); //true
System.out.println(s3.equals("hello"+"world")); //true
}
}
2.3StringBuilder
StringBuilder是封装的一个字符数组，该数组非final修饰，可以不断修改。所以对于一些经常需要修改字符串的情况，我们首选StringBuilder。
StringBuilder线程不安全的可变字符序列
StringBuilder中的方法：
1)构造方法
StringBuilder()//以默认容量创建空的StringBuilder对象
StringBuilder(int capacity)//以指定容量创建空的StringBuilder对象
StringBuilder(String str)//以指定的字符串创建StringBuilder对象
2)成员方法
获取功能
int capacity()//获取容量
int length()//获取长度
添加功能
append(int value)//追加。可以追加多种类型
insert(int offset,String s)//在指定的位置插入指定数据
删除功能
deleteCharAt(int index)//删除指定索引处的元素
delete(int start,int end)//删除[start,start-1]范围内的元素
替换功能
replace(int start,int end,String s)//将[start,end-1]范围内的元素替换成指定字符串
反转功能
reverse()//元素反转
截取功能
String subString(int start)//截取指定位置一直到末尾
String subString(int start,int end)//截取[start,end-1]范围
2.4StringBuffer
StringBuffer 类似一个字符容器，当在其中添加或删除字符时，所操作的都是这个字符容器，因此并不会产生新的 StringBuffer 对象。
StringBuffer类的初始化方式：
StringBuffer 变量名=new String(字符串);
StringBuffer常用方法：
length()//StringBuffer对象调用该方法获取实体中存放的字符串的长度；调用capacity()方法，获取当前实体的总容量（实体中除了字 符串还有没有使用的容量）。 StringBuffer append(String s)//将一个字符串对象追加到当前对象的中，并返回当前StringBuffer对象的引用。 append(int n)//将以个int型数据转化为字符串对象后追加到当前StringBuffer对象，并返回当前StringBuffer 对象的引用。 append(Object o)//将一个Object对象的字符串表示追加到当前StringBuffer对象，并返回当前StringBuffer对象的引用。 public char chatAt(int n)//得到参数n指定位置上的单个字符。当前字符串的第一个字符的位置为0，n不能超过对象实体的范围。 public void setCharAt(int n,char ch)//将当前对象实体中的字符串的位置为n处的字符用参数ch指定的字符替换。n不能超过对象实体的 范围。 StringBuffer insert(int index,String str)//将参数str指定的字符串插入到参数index指定的位置，并返回当前对象的引用。 public StringBuffer reverse()//将对象实体中的字符翻转，并返回当钱对象的应用。 StringBuffer delete(int startIndex,int endInex)//删除当前对象实体中startInex到endIndex-1的字符串，并返回当前对象的引用。 deleteCharAt(int index)//删除当前StringBuffer对象实体的字符串中index位置处的一个字符。 StringBuffer replace(int startIndex,int endIndex,String str)//替换指定的字符串。 int indexOf(String s）//返回当前对象的实体中第一个符合参数指定字符串的第一个首字母的位置。
2.5System
System类是一些与系统相关属性和方法的集合，而且在System类中所有的属性都是静态的，要想引用这些属性和方法，直接使用System类调用,这个类位于java.lang。
System常用方法：
exit ( int status ) //终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。 gc ()//运行垃圾回收器。调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存。当控制权从方法调用中返回时，虚拟机已经尽最大努力从所有丢弃的对象中回收了空间。 arraycopy(Object src, int srcPos, Object dest, int destPos,int length) 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。 currentTimeMillis()//返回以毫秒为单位的当前时间。（常用来计算一个程序执行时间） getProperties()//确定当前的系统属性。 getProperties(String key)//获取系统某一属性。key - 系统属性的名称。
运用实例：
public class Main {
public static void main(String[] args) {
long begin = System.currentTimeMillis();//开始时间
int sum=0;
for (int i = 0; i < 100000; i++) {
sum+=i;
}
long end = System.currentTimeMillis();//结束时间
System.out.println("用时："+(end-begin)+"ms");//循环所用时间
System.out.println("操作系统的名称："+System.getProperty("os.name"));//获取本机操作系统
System.out.println(System.getProperties());//获取本机的全部环境属性
}
}
2.6Data
表示特定的瞬间，精确到毫秒值
常用方法：
Date()//以当前时间毫秒值创建Date对象 Date(long time)//以指定的毫秒值创建Date对象 long getTime(）//获取Date对象的毫秒值 setTime(long time)//设置Data对象的毫秒值
2.7SimpleDateFormat
SimpleDateFormat包含在java.text包下面，是用来格式化和解析日期的具体类。日期和时间的格式由日期和时间模式字符串来确定。在日期和时间模式字符串中，未加引号的字母 ‘A’ 到 ‘Z’ 和 ‘a’ 到 'z’会被特殊处理替换为对应的日期时间，用format()方法来格式化；用pase()方法来解析。
模式字符串及其对应日期和时间
yyyy//年 MM//月 dd//日 hh//1~12小时制(1-12) HH//24小时制(0-23) mm//分 ss//秒 S//毫秒 E//星期几 D//一年中的第几天 F//一月中的第几个星期(会把这个月总共过的天数除以7) w//一年中的第几个星期，w为小写 W//一月中的第几星期(会根据实际情况来算)，w为大写 a//上下午标识 k//和HH差不多，表示一天24小时制(1-24)。k为小写 K//和hh差不多，表示一天12小时制(0-11)。k为大写 z//表示时区
实例：
import java.text.SimpleDateFormat;
import java.util.Date;
public class Format {
public static void main(String[] args) {
Date ss = new Date();
System.out.println("一般日期输出：" + ss);
System.out.println("时间戳：" + ss.getTime());
SimpleDateFormat format0 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String time = format0.format(ss.getTime());//这个就是把时间戳经过处理得到期望格式的时间
System.out.println("格式化结果0：" + time);
SimpleDateFormat format1 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
time = format1.format(ss.getTime());
System.out.println("格式化结果1：" + time);
}
}
