首页 > 编程语言> > Java学习_20220615

Java学习_20220615

2022-06-15 16:01:25 作者：互联网

Java集合框架

1. Map集合

将键映射到值的对象，一个映射不能包含重复的键，每个键最多只能映射到一个值。

Map<String,String> map = new HashMap<>();
//添加
map.put("CN","中国");
map.put("UK","英国");
map.put("USA","美国");
System.out.println(map.toString());//{USA=美国, UK=英国, CN=中国}
map.put("CN","Zhongguo");//键相同会将值改变
System.out.println("个数:"+map.size()); 
System.out.println(map.toString());//{USA=美国, UK=英国, CN=Zhongguo}
 //删除：只能按照键进行删除
 map.remove("USA");//map.remove("美国"); 
 System.out.println("个数:"+map.size());
 System.out.println(map.toString());
//使用keyset()遍历，取出map中的key,调用map.get(key)获取值
Set<String> keyset = map.keySet(); //keyset是所有的键的集合
for (String key : keyset ) { //map.get(key)可以把当前key的值取出来
     System.out.println(key+"----"+map.get(key));
}
//使用Map.Entry<>是映射对，直接获取到key和value,效率更高
Set<Map.Entry<String, String>> entries = map.entrySet();
for(Map.Entry<String, String> entry : entries){//写成一句：for(Map.Entry<String, String> entry : map.entrySet())
      System.out.println(entry.getKey()+"---"+entry.getValue());
}
//判断
System.out.println(map.containsKey("CN"));
System.out.println(map.containsValue("英国"));

Map的实现类

（1）HashMap()，线程不安全，运行效率快，允许用null作为key或者value. 构造一个具有默认初始容量（16）和默认加载因子（0.75）的空HashMap。

//Student类中成员有name和sno，构造函数，Get和Set访问器，
//重写了equals和hashcode函数，保证在键相同且值相同的情况下，不能插入到HashMap中
//在键相同值不同的情况下，改变HashMap中对应键的值。

//创建集合
HashMap<Student, String> stu = new HashMap<>();
//添加元素
Student s1 = new Student("张三", 2022001);
Student s2 = new Student("李四", 2022002);
Student s3 = new Student("王五", 2022003);
stu.put(s1,"北京");
stu.put(s2,"上海");
stu.put(s3,"杭州");
stu.put(new Student("王五", 2022003),"nanjin");
System.out.println(stu.toString());
//遍历 Set<Student> set = stu.keySet(); for(Student key : set){
for(Student key : stu.keySet()){
    System.out.println(key.toString()+"---"+stu.get(key));
}
//Set<Map.Entry<Student, String>> entries = stu.entrySet();
//for(Map.Entry<Student, String> en :entries){
for(Map.Entry<Student, String> en :stu.entrySet()){
    System.out.println(en.getKey()+"===="+en.getValue());
}

HashMap总结

HashMap刚创建的时候，table是null，为了节省空间，当添加第一个元素时，table容量调整为16；
当元素个数大于阈值（16*0.75=12）时，会进行扩容，扩容后大小为原来的2倍，目的是减少调整元素的个数。
jdk1.8 当每个链表的长度大于8，并且数组元素个数大于等于64时，会调整为红黑树，目的时提高执行效率；
jdk1.8 当链表长度小于6时，调整成链表；
jdk1.8以前，链表时头插入，jdk1.8后是尾插入。

new HashSet 是实际上是实例化了一个HashMap，存储时用的是HashMap的key来保存数据。

（2）TreeMap

TreeMap<Object, Object> tree = new TreeMap<>();

使用put出错，必须实现Comparable接口重写compareTo类

public class Student implements Comparable<Student>{
     @Override
    public int compareTo(Student o) {
        int n1 = this.name.compareTo(o.getName());
        int n2 = this.sno-o.getSno();
        return n2 == 0?n1:n2;
    }
}

new TreeSet == new TreeMap

2. Collections工具类

添加集合

List<Integer> list = new ArrayList<>();
list.add(10);
list.add(20);
list.add(4);
list.add(3);
list.add(90);
System.out.println(list.toString());//[10, 20, 4, 3, 90]

集合中的元素排序 sort

Collections.sort(list);
System.out.println(list);//[3, 4, 10, 20, 90]

查找集合中元素的位置

//binarySearch 二分查找
int i = Collections.binarySearch(list, 10);
int y = Collections.binarySearch(list, 111111);
System.out.println(i);//2
System.out.println(y);//-6

复制copy()

//copy复制
List<Integer> dest = new ArrayList<>();
for(int x =0;x<list.size();x++){
    dest.add(0);
}
Collections.copy(dest,list); //直接复制大小不一，数组未添加元素时大小为0
System.out.println("dest："+dest.toString());//dest：[3, 4, 10, 20, 90]

数组反转reserve()

Collections.reverse(dest);
System.out.println("dest："+dest.toString());//dest：[90, 20, 10, 4, 3]

数组打乱shuffle()

Collections.shuffle(dest);
System.out.println("dest："+dest.toString());//每次调用，排序都不一样

List转成数组 toArray()

//list转成数组 new Integer[0]数字<=list的长度，数组为原list，[3, 4, 10, 20, 90]
// 若大于（如10），用null填充
// [3, 4, 10, 20, 90, null, null, null, null, null]
Integer[] arr = list.toArray(new Integer[3]);
System.out.println(Arrays.toString(arr));//[3, 4, 10, 20, 90]

数组转成集合

//数组变为集合(受限集合，不能添加和删除)
String[] name = {"中国","韩国","泰国","英国"};
List<String> listname = Arrays.asList(name);
System.out.println(listname);//[中国, 韩国, 泰国, 英国]
//把基本类型数组转成集合时，需要修改为包装类
Integer[] nums = {100,3,24,555,63};
List<Integer> listnum = Arrays.asList(nums);
System.out.println(listnum);//[100, 3, 24, 555, 63]

IO框架

1. 流

内存与存储设备之间传输数据的通道。

按方向划分流：

输入流：将<存储设备>中的内容读如到<内存>中。
输出流：将<内存>中的内容写入到<存储设备>中。

按单位划分流：

字节流：以字节为单位，可以读写所有数据；
字符流：以字符为单位，只能读写文本数据。

按功能划分流：

节点流：具有实际传输数据的读写功能；
过滤流：在节点流的基础之上增强功能。

（1）字节流

父类（抽象类）：

InputStream：字节输入流（read()）

OutputStream：字节输出流(write())

实现类：

FileInputStream

FileOutputStream

标签：map,Java,20220615,System,学习,key,println,new,out
来源： https://www.cnblogs.com/Joyce-mi7/p/16378749.html