Java部分集合与常用类的学习

集合

• Set

set的理解：

1. Map用于存储key-value的映射，对于充当key的对象，是不可以重复的，并且，不但需要正确覆写equals()方法，还要正确覆写hashCode()方法。
2. 如果我们只需要存储不重复的key，并不需要存储映射的value，那么就可以使用Set
3. Set用于存储不重复的元素集合，它主要提供以下几个方法

     （1）将元素添加进Set<E>：boolean add(E e)

     （2）将元素从Set<E>删除：boolean remove(Object e)

     （3）判断是否包含元素：boolean contains(Object e)

代码练习:

package jihe;
import java.util.*;    //导入util下所有的类
public class jihe_Set {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        System.out.println(set.add("abc"));     //true
        System.out.println(set.add("xyz"));     //true
        System.out.println(set.add("xyz"));     //false,添加失败，元素已存在
        System.out.println(set.contains("xyz"));      //true,元素存在
        System.out.println(set.contains("XYZ"));      //false,元素不存在
        System.out.println(set.remove("hello"));    //false,删除失败，元素不存在
        System.out.println(set.size());                //为2，共有两个元素
    }
}
       //将元素添加进Set<E>：boolean add(E e)
       // 将元素从Set<E>删除：boolean remove(Object e)
       //判断是否包含元素：boolean contains(Object e)

Set实际上相当于只存储key、不存储value的Map。我们经常用Set用于去除重复元素。

因为放入Set的元素和Map的key类似，都要正确实现equals()和hashCode()方法，否则该元素无法正确地放入Set。

最常用的Set实现类是HashSet，实际上，HashSet仅仅是对HashMap的一个简单封装，它的核心代码如下：

public class HashSet<E> implements Set<E> {
    // 持有一个HashMap:
    private HashMap<E, Object> map = new HashMap<>();
    // 放入HashMap的value:
    private static final Object PRESENT = new Object();
    public boolean add(E e) {
        return map.put(e, PRESENT) == null;
    }
    public boolean contains(Object o) {
        return map.containsKey(o);
    }
    public boolean remove(Object o) {
        return map.remove(o) == PRESENT;
    }
}

• Map

1.通过一个键去查询对应的值。使用List来实现存在效率非常低的问题，因为平均需要扫描一半的元素才能确定，而Map这种键值（key-value）映射表的数据结构，作用就是能高效通过key快速查找value（元素）

用Map来实现根据name查询某个Student的代码示例：

import java.util.HashMap;
import java.util.Map;
public class practice {
    public static void main(String[] args) {
        Student s=new Student  ("Xiao Ming",99);
        Map<String,Student>map=new HashMap<>();
        map.put("Xiao Ming",s);     ///将“Xiao Ming”和Student实例化
        Student target=map.get("Xiao Ming");  //通过key查找并返回映射的Student实例
        System.out.println(target==s);   //true,同一个实例
        System.out.println(target.score);   //99
        Student another=map.get("Bob");   //通过另外一个key查找
        System.out.println(another);   //未找到返回null
    }
}

Map<K, V>是一种键-值映射表，当我们调用put(K key, V value)方法时，就把key和value做了映射并放入Map。当我们调用V get(K key)时，就可以通过key获取到对应的value。如果key不存在，则返回null。和List类似，Map也是一个接口，最常用的实现类是HashMap

一个key只能关联一个value

Map中不存在重复的key，因为放入相同的key，只会把原有的key-value对应的value给替换掉，

此外，在一个Map中，虽然key不能重复，但value是可以重复的

• list

1. List是集合类最基础的一种集合：它是一种有序链表
2. List的行为和数组几乎完全相同：List内部按照放入元素的先后顺序存放，每个元素都可以通过索引确定自己的位置，List的索引和数组一样，从0开始
3. 数组和List类似，也是有序结构，如果我们使用数组，在添加和删除元素的时候，会非常不方便,List接口允许添加重复的元素
4. List<E>接口的的几个方法:

• 在末尾添加一个元素：void add(E e)
• 在指定索引添加一个元素：void add(int index, E e)
• 删除指定索引的元素：int remove(int index)
• 删除某个元素：int remove(Object e)
• 获取指定索引的元素：E get(int index)
• 获取链表大小（包含元素的个数）：int size()

实现List接口并非只能通过数组（即ArrayList的实现方式）来实现，另一种LinkedList通过“链表”也实现了List接口。在LinkedList中，它的内部每个元素都指向下一个元素

	ArrayList	LinkedList
获取指定元素	速度很快	需要从头开始查找元素
添加元素到末尾	速度很快	速度很快
在指定位置添加/删除	需要移动元素	不需要移动元素
内存占用	少	较大

常用类

• Object

• SimpleDateFormat

构造方法

1. 空参构造: SimpleDateFormat simpleDateFormat = new SimpleDateFormat();    没有指定格式,按照默认格式输出
2. 有参构造: SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("放入时间格式 ");  按照指定格式输出.

//这里面的格式是有要求的哈!( yyyy表示年 / MM表示月 / dd表示天 / HH表示时 / mm表示分 / ss表示秒 / E表示星期 常用的就是这些,还有很多呢,需要的话可以在api帮助文档里查查

package jihe;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Practice {
    public static void main(String[] args) {
        Date date = new Date(System.currentTimeMillis());
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(formatter.format(date));
    }
}

     //输出结果为     2022-06-30 10:38:42

• String

创建方式1.

String str = “hello”；

使用双引号括起来的叫字符串常量值，字符串常量值分配在方法区的常量池中

常量池的好处：

1. 节约内存，反复使用，不需要重新分配
2. 性能高，直接调用，省去创建对象的时间

代码示例：

String name1 = "zhangsan";
String name2 = "zhangsan";
System.out.println(name1==name2);  			输出true
System.out.println(name1.equals(name2)); 	输出true

1. equals是用于比较String的内容，==用于比较String对象的内存地址
2. name1=“zhangsan”，在常量池中创建“zhangsan”
3. name2=“zhangsan”，会把池中常量的地址直接赋值给name2

创建方式2.

String name = new String（“zhangsan”）；

//使用new都会在堆中创建新的对象

常用方法：

1. int length（）    //获得字符串长度
2. int indexOF（String s）   //获得子字符串出现的位置
3. int indexOF(String s,int start)      //在字符串中查找子字符串第一次出现的位置，没找到返回-1
4. int lastIndexOF（String s）    //指定了开始查找的位置
5. String replace（String oldStr，String newStr）    //替换

• StringBuilder

当字符串变量需要频繁修改，就会创建大量字符串对象，大量消耗内存空间，此时可以用StringBuilde

String和StringBuilder的区别：1.String的字符串是不可修改的，修改时会创建新字符串，浪费内存

2.StringBuilder的字符串可以修改，不会创建新字符串

创建方法：

//创建空值的对象
StringBuilder strb = new StringBuilder();
//创建有默认值的对象
StringBuilder strb = new StringBuilder("默认值");

StringBuilder的常用方法：

1. String toString      //替换为String
2. StringBuilder replace(int start,int end,String newS)     //替换
3. StringBuilder insert(int offset,String s)     //插入
4. StringBuilder delete(int start,int end)     //删除

• StringBuffer

StringBuffer的特点和StringBuilder相似，都在自身数组上进行修改，常用方法也一样

不同点：

1. StringBuffer的方法是线程安全的，StringBuilder是非线程安全的
2. StringBuffer的执行效率低于StringBuilder

• System

System类代表当前Java程序的运行平台，程序不能创建System类的对象，System类提供一些类变量和类方法

常用方法：

修饰符	返回值类型	方法（形参）	说明
static	long	currentTimeMillis（）	返回以毫秒为单位的当前时间
static	void	exit（int status）	终止当前正在运行的Java虚拟机
static	void	gc（）	运行垃圾回收器
static	Map	getenv()	返回一个不能修改的当前系统环境的字符串映射图
static	String	getenv（String name）	获取指定的环境变量值
static	int	identityHashCode（Object x）	返回给指定对象的哈希码，改代码与默认的方法hashCode（）返回的代码一样，无论给定对象的类是否重写hashCode（）
static	long	nanoTime（）	返回最准确的可用系统计时器的当前值，以豪微秒为单位

代码示例：

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.FileSystemAlreadyExistsException;
import java.util.Map;
import java.util.Properties;

public class SystemTest {
    public static void main(String[] args) throws FileNotFoundException,IOException{
        //获取系统所有的环境变量
        Map<String,String>envMap=System.getenv();
        for (String name:envMap.keySet()){
            System.out.println(name+"--->"+envMap.get(name));
        }
        //获取指定的环境变量
        System.out.println(envMap.get("JAVA_HOME"));
        //获取所有的系统属性
        Properties props = System.getProperties();
        //将所有的系统属性保存到props.txt文件中
        props.store(new FileOutputStream("props.txt"),"System Properties");
        //输出特定的系统属性
        System.out.println(System.clearProperty("os.name"));
    }

}

• Data

java.util.Data类，表示特定的瞬间，精确到毫秒

常用方法：

1. public Data（）：分配Data对象并初始化此对象，以表示分配它的时间（精确到毫秒）
2. public Data（Long data）：分配Data对象并初始化此对象，以表示从基准时间（即1970年1月1日00:00:00GTM）以来的指定毫秒数 
3. public Long getTime（）：把日期对象转换成对应的时间毫秒值

       //简单来说，使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定Long类型的构造参数可以自定义毫秒时刻 

System.out.println（new Date（））；——>当前时间

System.out.println（new Data（0L））；——>把当前的毫秒值转成日期对象。