Java学习第十五天

1.Map:独立的接口

　　　　---HashMap:使用的是哈希表，保证键不重复依据: int hashCode() boolean equals(Object obj)

　　　　---TreeMap:使用的是二叉树，根据键排序，Comparable<E> int compareTo(E e) Comparator<E> int compare(E e1,E e2)

　　　　注意：compareTo()或compare方法返回值为0则认为是相同的键

2.数组转字符串：
　　Arrays.toString()
　　例：int[] arr={2,4,5,6,7,8};
　　String ss = Arrays.toString(arr);

3.数组转集合:

　　Arrays.asList()
　　缺点：数组转成的集合不能添加或删除数据，不能扩容
　　例：String[] arr2 = {"hello","haha","hehe"};
　　List<String> list=Arrays.asList(arr2);

　　目的：可以利用集合集合的丰富的方法

4.集合转数组：

　　Object[] toArray()
　　<T> T[] toArray(T[] a)

　　注意：
　　　　1.给定的数组长度大于集合大小，使用给定的数组
　　　　2.给定的数组长度小于集合大小，会创建一个新的数组并返回
　　　　3.给定的数组长度最好和集合的size相同
　　　　例：String[] arr=list.toArray(new String[list.size()]);
　　目的：当不希望对数据进行随意增删时

 5.集合的工具类:

　　<T extends Comparable<? super T>> void Collections.sort(List<T> t)

Collections.sort(List<T> t)
Collections.sort(List<T> t,Comparator c)
Comparator Collections.reverseOrder()
Collections.max(Collection list)
Collections.reverse(List list);

例子：
import java.util.*;

class ComByLeng implements Comparator<String>
{
public int compare(String s1,String s2){
int n = s1.length()-s2.length();
return n==0?s1.compareTo(s2):n;
}
}
class Demo6 
{
public static void main(String[] args) 
{
//使用list集合，还要排序
//static <T extends Comparable<? super T>> void sort(List<T> list) 

List<Student> list = new ArrayList<>();
list.add(new Student("lisi",21));
list.add(new Student("zhaosi",20));
list.add(new Student("wangsi",18));

Collections.sort(list);
sop(list);

List<String> list = new ArrayList<>(); //String implements Comparable
list.add("zwoieurowie"); 
list.add("wlksjioerwerwreserere");
list.add("alks");

//Collections.sort(list);//用的是集合中对象默认的排序规则
//Collections.sort(list,Collections.reverseOrder()); //按字符串从大到小排序
//sop(list);

//Collections.sort(list,new ComByLeng());//使用自定义的排序方式排序,按照字符串长度排序
//Collections.sort(list,Collections.reverseOrder(new ComByLeng())); //按字符串长度从长到短排序
//sop(list);

//static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) 
//String max = Collections.max(list);//求集合中的最大值
//sop(max);

Collections.reverse(list);//反转集合
sop(list);
}
public static void sop(Object obj){
System.out.println(obj);
}
}

6.集合中的对象不重复，有序：

　　LinkedHashSet : Collections.synchronizedSet(new LinkedHashSet())

　　LinkedHashMap : Collections.syncharonizedMap(new LinkedHashMap())
　　注意：本身都是线程不安全的，但是可以Collections.synchronizedMap()方法定义线程安全的

例：
import java.util.*;
class Demo7 
{
public static void main(String[] args) 
{
//希望集合中的对象不重复，还希望有序

//使用了两种数据结构，为了实现数据的有序 123 123
//线程不安全的
LinkedHashSet<String> lhs = new LinkedHashSet<>();
lhs.add("java01");
lhs.add("java02");
lhs.add("java03");

//sop(lhs);

//创建线程安全的LinkedHashSet对象
Set<String> set=Collections.synchronizedSet(new LinkedHashSet<String>());
set.add("java05");
set.add("java06");
set.add("java07");

//sop(set);



LinkedHashMap<String,String> lhm = new LinkedHashMap<>();
lhm.put("name","lisi");
lhm.put("age","20");
lhm.put("address","shanghai");

//sop(lhm);

//创建线程安全的LinkedHashMap对象
Map<String,String> map = Collections.synchronizedMap(new LinkedHashMap<String,String>());
map.put("name","lisi");
map.put("age","20");
map.put("address","shanghai");

sop(map);


//SortedSet----TreeSet SortedMap----TreeMap
}


public static void sop(Object obj){
System.out.println(obj);
}
}

7.SortedSet ---TreeSet
　SortedMap ---TreeMap

8.增强的for循环：

　　for(数据类型 变量名:被遍历的Collection集合或数组){}
　　注意：对数组使用增强的for循环，不能操作下标

9.可变参数：数组的原理
　　定义：void show(int ... a){}
　　List<T> asList(T... a)

　　注意：可变参数必须位于参数列表的最后

 

10.静态导入： import static java.util.Arrays;
　　作用：可以省略类名不写，例如：import static java.util.Arrays;在调用Arrays的静态方法时，可以直接写方法名，不写Arrays
　　注意：有相同的方法名，类名不能省略，
　　　　　方法名相同了，类名不能省
　　　　　类名相同了，包名不能省略，通过包名来区分

　　

Properties：是一个Map集合类,默认的键和值必须是String类型，存储属性
Properties pro = System.getProperties();//得到的是系统属性集

Set<String> keys=pro.stringPropertyNames();//得到集合中所有的键的集合

for(String key:keys)
{
String v=pro.getProperty(key);
System.out.println(key+"="+v);
}

pro.setProperty("line.separator","
");//相当于Map中的put 覆盖集合中同名的键值对，不会修改本来的数据，只是修改集合中的数据

 

11.IO流:(input output)输入输出流，用来实现设备之间的数据传输

　　IO流的分类：
　　　　按照方向分：输入流，输出流(相对于内存的)

　　　　按照操作的数据分：
　　　　　　字节流：可以操作任何类型的数据，文本，图片，音频，视频

　　　　　　字符流：只能操作文本类型的数据，字符流是在字节流的基础上融入了编码，
　　　　　　　　　　所以说字符流是基于字节流的

　　　　常见编码：ASCII，ISO8859-1(欧洲编码表)，gb2312,gbk,UTF-8

12.字节流（输入，输出）
　　InputStream 字节输入流的父类
　　OutputStream 字节输出流的父类

13.字符流（输入，输出）
　　Reader 字符输入流的父类
　　Writer 字符输出流的父类

14字符流：设备：硬盘
　　使用FileWriter
　　　　1.创建文件输出流对象和文件相关联 ，文件可以事先存在，也可以不存在，如果不存在就会自动创建

　　　　FileWriter fileWriter=ewn FileWriter("temp.txt");
　　　　2.使用文件输出流对象向文件中写入数据(要抛出异常)
　　　　fileWriter.write("abc");//因为需要一个查表的过程，数据先写入到流对象内部的缓冲区了

　　　　3.把缓冲区中的数据刷到文件中
　　　　fileWriter.flush()

　　　　4.关闭流(关闭后不能再写入数据，并且关闭流时会先刷新，即flush())
　　　　fileWriter.close()