Java学习第十五天

2019-08-26 06:48:19来源：博客园阅读 ()

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);

 1 例子：
 2 import java.util.*;
 3 
 4 class ComByLeng implements Comparator<String>
 5 {
 6 public int compare(String s1,String s2){
 7 int n = s1.length()-s2.length();
 8 return n==0?s1.compareTo(s2):n;
 9 }
10 }
11 class Demo6 
12 {
13 public static void main(String[] args) 
14 {
15 //使用list集合，还要排序
16 //static <T extends Comparable<? super T>> void sort(List<T> list) 
17 
18 List<Student> list = new ArrayList<>();
19 list.add(new Student("lisi",21));
20 list.add(new Student("zhaosi",20));
21 list.add(new Student("wangsi",18));
22 
23 Collections.sort(list);
24 sop(list);
25 
26 List<String> list = new ArrayList<>(); //String implements Comparable
27 list.add("zwoieurowie"); 
28 list.add("wlksjioerwerwreserere");
29 list.add("alks");
30 
31 //Collections.sort(list);//用的是集合中对象默认的排序规则
32 //Collections.sort(list,Collections.reverseOrder()); //按字符串从大到小排序
33 //sop(list);
34 
35 //Collections.sort(list,new ComByLeng());//使用自定义的排序方式排序,按照字符串长度排序
36 //Collections.sort(list,Collections.reverseOrder(new ComByLeng())); //按字符串长度从长到短排序
37 //sop(list);
38 
39 //static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) 
40 //String max = Collections.max(list);//求集合中的最大值
41 //sop(max);
42 
43 Collections.reverse(list);//反转集合
44 sop(list);
45 }
46 public static void sop(Object obj){
47 System.out.println(obj);
48 }
49 }

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","\r\n");//相当于Map中的put 覆盖集合中同名的键值对，不会修改本来的数据，只是修改集合中的数据