Java中的集合

List系列集合：

ArryList，LinkedList：其集合中的元素是有序的，可重复的并且每个元素都有索引值。

 ArrayList的底层是基于数组实现的，其优点是可以根据索引查询元素速度快，缺点是删除、插入速度慢。

LinkedList的底层是基于双链表实现的，有点是插入、删除速度快，但查询较慢。

可以根据具体的使用场景对以上两种方式进行最优选择。

下面介绍List的实现类的几种常用API：

public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。

    public E get(int index):返回集合中指定位置的元素。

    public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。

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

首先我们要创建一个List的集合对象：

List<Integer> list=new List<>();//第一个尖括号里需要写泛型，第二个尖括号里可写可不写

package Set;

import java.util.ArrayList;
import java.util.List;

public class ListDemo1 {
public static void main(String[] args) {
	List<Integer> list=new ArrayList<>();
//1、add
	list.add(6);                //先往集合内添加元素6
	System.out.println(list);
	list.add(2);                //插入2
	System.out.println(list);
    list.add(1, 3);             //根据索引插入
	System.out.println(list);
	System.out.println(list.get(2));//获取2号位置的元素值
	System.out.println(list);
	System.out.println(list.remove(0));//删除0号位置的元素remove的返回值是被删除的元素
	System.out.println(list);
	list.set(0, 9);//将0号位置的元素修改为9
	System.out.println(list);//输出集合内的元素
}
}

输出结果

[6]
[6, 2]
2
[6, 3, 2]
6
[3, 2]
[9, 2]

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。

Set系列集合：

特点：无序，不重复，无索引（不能通过for循环遍历）

set集合的实现类：

LinkedHashSet：有序，不重复，无索引

package Set;

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

public class SetDemo2 {
public static void main(String[] args) {
	Set<String> set= new LinkedHashSet<>();//LinkedHashSet
	set.add("2");
	set.add("张三");
	set.add("李四");
	set.add("王五");
	set.add("张三");
	set.add("张三");
	System.out.println(set);
}
}

运行结果：与添加的顺序一致 且不重复

[2, 张三, 李四, 王五]

HashSet：无序不重复无索引

package Set;

import java.util.HashSet;
import java.util.Set;

public class SetDemo2 {
public static void main(String[] args) {
	Set<String> set= new HashSet<>();//HashSet
	set.add("2");
	set.add("张三");
	set.add("李四");
	set.add("王五");
	set.add("张三");
	set.add("张三");
	System.out.println(set);
}
}

运行结果：与添加顺序有差异

[李四, 2, 张三, 王五]

Map

Map集合的概述和使用：

特点：

Map集合是一个键值对集合，每一个键都有一个值与其对应，且map集合的键是无序不重复的，但值可以重复。

集合中后面的键如果与前面的键重复的话，那么后面的键对应的值会覆盖前面相同键的值。

集合的键值对可以为空；

Map的实现类： HashMap和LinkedHashMap;

其中HashMap的元素按照键是无序，不重复，无索引。

LinkedHashMap的元素按照键是有序，不重复，无索引。

如何创建一个Map对象：Map<K,V> m=new HashMap<>();//K和V都需填泛型；

常用的几个方法：

Object put(Object key,Object value):添加一个键值对，如果集合中的key重复，则覆盖原来的键值对；

package MapDemo1;

import java.util.HashMap;
import java.util.Map;

public class Test {
	public static void main(String[] args) {
		Map<String,Integer> m=new HashMap<>();
	//添加元素  put	
		m.put("苹果", 2);
		m.put("香蕉", 5);
		m.put("西瓜", 2);
		m.put("苹果", 6);
		System.out.println(m);//    输出结果{苹果=6, 香蕉=5, 西瓜=2}  值为6的苹果对值为2的发生覆盖
}

void clear():删除该Map对象中所有键值对；

        m.clear();
		System.out.println(m);//输出结果为 {}， 当调用clear方法时，集合清空。

boolean containsKey(Object key):查询Map中是否包含指定的key值；
boolean containsValue(Object value):查询Map中是否包含一个或多个value;
Set entrySet():返回map中包含的键值对所组成的Set集合，每个集合都是Map.Entry对象。
Object get()：返回指定key对应的value，如果不包含key则返回null；
boolean isEmpty():查询该Map是否为空；
Set keySet():返回Map中所有key组成的集合；
Collection values():返回该Map里所有value组成的Collection。
void putAll(Map m):将Map中的键值对复制到本Map中；
Object remove(Object key):删除指定的key对应的键值对，并返回被删除键值对的value，如果不存在，则返回null；
boolean remove(Object key,Object value):删除指定键值对，删除成功返回true；
int size():返回该Map里的键值对个数；

使用方法都与put类似 ，不一一展示；

Object类

1.Object类是超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
2.任何类如没有书写extends显示继承某个类，都默认直接继承0bject类，否则为间接继承。
3.0bject类中所定义的方法，是所有对象都具备的方法。
4.0bject类型可以存储任何对象。
（1）作为参数，可接受任何对象。
（2）作为返回值,可返回任何对象。

toString()方法：

返回该对象的字符串表示：默认返回：全类名 + @ + 哈希值的十六进制（对象在堆内存中的地址）

根据需要对toString方法重写来展示类的各种属性值,如下代码对toString进行了重写：

package com.object;

public class Day01 {
	public static void main(String[] args) {
		Weapon w=new Weapon("RPG","as",1999);
		System.out.println(w);
	}
}
class Weapon {
 public String name;
 public String aim;
 public  int price;

 public Weapon(String name, String aim, int price) {
	super();
	this.name = name;
	this.aim = aim;
	this.price = price;
}

public String toString() {//重写toString方法
	return "武器名称:"+name+"\n"+"aim:"+aim+"\n"+"price:"+price;
 }
}

结果如下：

//重写toString方法的输出结果
武器名称:RPG
aim:as
price:1999


//如果没重写toString方法时输出结果如下
com.object.Weapon@7de26db8

equals()方法
public boolean equals(Object anObject) {}
1
默认实现为（this == obj）,比较两个对象的地址是否相同

对equals方法进行重写，比较两个对象的内容是否相同

finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。

垃圾对象:没有有效引用指向此对象时,为垃圾对象。 垃圾回收:由GC销毁垃圾对象,释放数据存储空间。

自动回收机制:JVM的内存耗尽，一次性回收所有垃圾对象。 手动回收机制:使用System. gc();通知JVM执行垃圾回收。

StringBuilder：

StringBuilder是一个可变的字符串类 ，其作用是提高字符串的拼接效率。

下面介绍几种StrikngBuilder的常用方法。

append();方法， 可以往字符串中添加或拼接字符，且支持链式编程，使用代码如下：

package api_stringbuilder;

public class StringBuilderDemo1 {
public static void main(String[] args) {
	 StringBuilder sb= new StringBuilder(); //创建一个空字符串对象
	 sb.append("a");						//往字符串中添加字符a
	 sb.append("b");						//往字符串中添加字符b，此种方法添加的字符都是添加在上一字符的后面
	 System.out.println(sb);				//此处输出应为 ab
	 StringBuilder sb1=new StringBuilder();
	 sb1.append("a").append("b");			//链式编程的方法来拼接
	 System.out.println(sb1);				//此处输出和sb字符串输出结果一样
}
}

输出结果：

sb:ab
sb1:ab
//两种方式结果相同，链式编程的方式更方便，简洁

reverse();方法，将字符串反转 。例如“abc”，调用reverse方法后输出结果为“cba”

	 StringBuilder sb= new StringBuilder(); //创建一个空字符串对象
	 sb.append("a");						//往字符串中添加字符a
	 sb.append("b");						//往字符串中添加字符b，此种方法添加的字符都是添加在上一字符的后面
	 System.out.println("sb:"+sb);				//此处输出应为 ab 
	 sb.reverse();							//字符串反转  
	 System.out.println(sb);				//输出ba
}
}

输出结果：

sb:ab
ba

StringBuffer

1.StringBuffer() 是线程安全的可变字符串

2.StringBuffer() 避免字符串拼接形成新的String对象，消耗内存和空间

3.StringBuffer() 长度和内容可变

4.StringBuffer() 三种构造方式：

• public StringBuffer() 无参数构造
• public StringBuffer(int capacity) 指定容量
• public StringBuffer(String str)  指定字符串内容

5.StringBuffer() 方法：

此处列举几种常用的方法，不做具体代码展示。

public int Capacity()  返回当前容量

public int length()  返回实际值

public StringBuffer append(String str)  //添加字符串str，返回字符缓冲区

public StringBuffer insert(int offset, String str)  //向任意位置，添加字符串str，返回字符缓冲区

public StringBuffer deleteCharAt(int index)  //删除指定字符，返回字符缓冲区

public StringBuffer delete(int start, int end)  //以start位置起，删除指定字符，返回字符缓冲区

public String substring(int start)  //从start位置开始截取，返回字符串

public String substring(int start, int end)  //从start截取到end位置，返回字符串

public StringBuffer replace(int start, int end, String str)  //从start截取到end位置，用str替换，返回字符缓冲区

public StringBuffer reverse()  //反转

System

system类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。

exit();方法，调用此方法时，jvm虚拟机将结束运行。

System.currentTimeMillis();可以输出此刻的时间，所以此方法可以用来性能分析，计算程序运行的时间，此处不做详细代码展示。

Date类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。

public static void main(String[] args) {
    Date date = new Date();
    System.out.println(date.getTime());//gettime()方法获取当前时间的毫秒数（从1970年1月1日开始）
    System.out.println(date);
    Date date2=new Date(date.getTime()-(60*60*24*1000));//用当前时间的毫秒数减去一天的毫秒数，得到昨天此时的时间
    boolean b=date2.before(date); //before()方法用于判断时间的前后
    System.out.println(b);
}

Calendar类
Calendar提供了获取或设置各种日历字段的方法构造方法
protected Calendar() :由于修饰符是protected，所以无法直接创建该对象。

其他方法：
1.static Calendar getInstance()：使用默认时区和区域获取日历
2.void set(int year,int month,int date,int hourofday,int minute,int second)设置日历的年、月、日、时、分、秒。
3.int get(int field)：返回给定日历字段的值。字段比如年、月、日等
4.void setTime(Date date)：用给定的Date设置此日历的时间。Date-Calendar
5.Date getTime()：返回一个Date表示此日历的时间。Calendar-Date
6.void add(int field,int amount)：按照日历的规则，给指定字段添加或减少时间量
7.long getTimelnMillies()：毫秒为单位返回该日历的时间值

public static void main(String[] args) {
    //创建对象
    Calendar calendar=Calendar.getInstance(); //不能直接实例化Calendar对象

    //获取时间，通过get()方法
    int year=calendar.get(Calendar.YEAR); //获取年
    int month=calendar.get(Calendar.MONTH); //获取月
    int day=calendar.get(Calendar.DAY_OF_MONTH); //获取日
    int hour=calendar.get(Calendar.HOUR_OF_DAY); //HOUR是12小时；HOUR_OF_DAY是24小时
    //月份要加1，因为该方法显示的月份是从0到11
    System.out.println("当前时间是："+year+"年"+(month+1)+"月"+day+"日"+hour+"时");

    //可以通过getMaximum（）和getMinimum（）获取当前月份的最大和最小时间
    Calendar calendar1=Calendar.getInstance();
    int num=calendar1.getMaximum(Calendar.DAY_OF_MONTH);//获取当前月份的最大天数
    System.out.println(num);
    int num1=calendar1.getMinimum(Calendar.DAY_OF_MONTH);//获取当前月份的最小天数
    System.out.println(num1);

}

SimpleDateFormat类
SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
进行格式化（日期->文本）、解析（文本->日期）。常用的时间模式字母

public static void main(String[] args) {
    //创建SimpleDateFormat对象
    SimpleDateFormat time= new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
    //创建Date对象
    Date date = new Date();
    //使用format()方法格式化,将日期转换成字符串
    String str=time.format(date);
    System.out.println(str);


    //把字符串转换成Date日期
    try {
        Date date1=time.parse("2020年12月11日 10:22:11");
        System.out.println(date1);
    } catch (ParseException e) {
        e.printStackTrace();
    }
}

System

system类代表系统，系统级的很多属性和控制方法都放置在该类的内部，主要用于获取系统的属性数据和其他操作。该类位于java.lang包。

exit();方法，调用此方法时，jvm虚拟机将结束运行。

System.currentTimeMillis();可以输出此刻的时间，所以此方法可以用来性能分析，计算程序运行的时间，此处不做详细代码展示。
public static void main(String[] args) {
    // src:原数组、srcPos:从哪个位置开始复制
    //dest:目标数组 、destPos:目标数组的开始位置 、length:复制的长度
    int[] arr=new int[]{11,22,33,44,55};
    int[] dest=new int[5];
    System.arraycopy(arr,0,dest,0,arr.length);
    System.out.println(Arrays.toString(dest));//使用arraycopy()方法实现数组的复制

    //通过currentTimeMillis()方法实现计算代码的运行时间
   

long start=System.currentTimeMillis();
    for (int i = 0; i < 9999; i++) {
        for (int j = 0; j < 999999; j++) {
            int result=i+j;
        }
    }
    long end=System.currentTimeMillis();
    System.out.println("运行时间为："+(end-start));
}