不可變集合

• 創(chuàng)建不可變的集合

  • 在創(chuàng)建了之后集合的長度內(nèi)容都不可以變化

    

• 靜態(tài)集合的創(chuàng)建在list ，set ，map接口當(dāng)中都可以獲取不可變集合

方法名稱	說明
static list of(E …elements)	創(chuàng)建一個具有指定元素集合list集合對象
staticlist of(E…elements)	創(chuàng)建一個具有指定元素的set集合
static<k,v> Map<k,v> of(E…elements)	創(chuàng)建一個具有指定元素的Map集合

• 這個集合是不能刪除和修改

• List集合

/*不能添加修改操作*/
List<String> list = List.of("lishi", "changff", "zhangshan", "wangshang");list.remove("lishi");list.add("shuxili");list.set(0,"bbbb");

• set集合
• 注意事項(xiàng)：信息不能重復(fù)

package ImmutableDemo;import java.util.Iterator;
import java.util.Set;public class Demo2  {public static void main(String[] args) {Set<String> s=Set.of("lishi", "changff", "zhangshan", "wangshang","dkjkjf");Iterator<String> it = s.iterator();while (it.hasNext() ) {System.out.println(it.next());}System.out.println("---------------");System.out.println("---------------");
//        s.remove("lishi");
//        s.add("shuxili");}
}

• map集合
• 注意事項(xiàng)：鍵值對信息不能重復(fù)

package ImmutableDemo;import java.util.Map;
import java.util.Set;public class Demo3 {public static void main(String[] args) {Map<String, String> mapDeom = Map.of("南京", "1000", "北京", "10000", "上海", "8000");Set<String> keySet = mapDeom.keySet();for (String s : keySet) {System.out.println(s);System.out.println(mapDeom.get(s));}System.out.println("---------");Set<Map.Entry<String, String>> entries = mapDeom.entrySet();for (Map.Entry<String, String> entry : entries) {String key = entry.getKey();String value = entry.getValue();System.out.println(key + "=" + value);}}
}

• Map

由于map集合的特殊，還有一種方法為Map.ofEntries( )方法可以傳遞多個鍵值對 對象

package ImmutableDemo;import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Demo4  {public static void main(String[] args) {HashMap<String,String> h =new HashMap<>();h.put("aaa","111");h.put("bbb","222");h.put("ccc","333");h.put("ddd","444");h.put("eee","555");/*先獲取鍵值對，對像*/Set<Map.Entry<String, String>> entries = h.entrySet();Map.Entry[] array = entries.toArray(new Map.Entry[0]);/*先將鍵值對對象轉(zhuǎn)化為數(shù)組，0長度不會影響，在底層會自動比較，然后轉(zhuǎn)成集合的長度*//*創(chuàng)建不可變集合*/Map map = Map.ofEntries(array);/*可變集合底層是一個數(shù)組，可以將數(shù)組直接傳過去*/
//        map.put("fff","777");
//        map.remove("aaa");/*簡寫*/Map<Object, Object> map1 = Map.ofEntries(h.entrySet().toArray(new Map.Entry[0]));}
}

總結(jié)：

• 特點(diǎn)：

  定義完成后不可以進(jìn)行增刪改

• 如何創(chuàng)建不可變集合

• 三種方式的細(xì)節(jié)
  

Stream流：

• 思想：工廠流水線，每個負(fù)責(zé)一項(xiàng)功能,結(jié)合lambda表達(dá)式來簡化對數(shù)組的操作

• Stream流的使用步驟：
  1.得到一條Stream流，并添加數(shù)據(jù)
  2.使用中間方法對流水線進(jìn)行操作
  3.使用終結(jié)方法結(jié)束對Stream的操作例如 sout

  獲取方法	方法名	說明
  單列集合	default Stream stream()	Collection 中的默認(rèn)方法
  雙列集合	無	無法直接使用stream流
  數(shù)組	Public static StramStream(T[] array)	Arrays工具類中的靜態(tài)方法調(diào)用
  一堆零散數(shù)據(jù)	public staticStream of(T…value)	Stream接口中的靜態(tài)方法

  • 單列集合

      public static void main(String[] args) {/*單列集合直接調(diào)用，list是collections的實(shí)現(xiàn)類*/ArrayList<String> list =new ArrayList<>();Collections.addAll(list,"A","B","C","E","F","G");list.stream().forEach(s -> System.out.println(s ));}
    

    • 雙列集合
      注意事項(xiàng)：不能直接使用，必須轉(zhuǎn)化為單列結(jié)合最后（keyset，entery）

      public static void main(String[] args) {HashMap<String,Integer> ha =new HashMap<>();ha.put("aaa",1);ha.put("bbb",2);ha.put("ccc",3);ha.put("ddd",4);ha.put("eee",5);/*獲取鍵值 */ha.keySet().stream().forEach(s -> System.out.println(s));System.out.println();/*獲取鍵值對 對象，*/ha.entrySet().stream().forEach(stringIntegerEntry -> System.out.println(stringIntegerEntry));}		
  

  • 數(shù)組

    注意事項(xiàng)：不能直接使用需要借助工具類arrays中的stream流

     /*數(shù)組*/public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};String [] st ={"aaa","bbb","ccc"};/*獲取stream流*/Arrays.stream(arr).forEach(s-> System.out.println(s));System.out.println();Arrays.stream(st).forEach(s1 -> System.out.println(s1));}	
    

  • 零散數(shù)據(jù)
    注意事項(xiàng)：數(shù)據(jù)的類型必須一致，在添加引用類型的數(shù)組是可以直接使用，但是基本數(shù)據(jù)類型的數(shù)組是不能使用的會吧整個數(shù)組當(dāng)成一個元素直接傳遞到steam流中

    public static void main(String[] args) {Stream.of(1,2,3,4,5,6,7,8,9).forEach(s-> System.out.println(s));}
    

stream流中的中間方法：

• Filter 過濾
  注意事項(xiàng)：stream流在使用一次后就自動關(guān)閉，不能在下面接著使用，建議鏈?zhǔn)骄幊?br /> 在stream流中修改了數(shù)據(jù)，原來集合里面的數(shù)據(jù)不會發(fā)生改變

ArrayList<String> list = new ArrayList<>();Collections.addAll(list, "aaa", "bbb", "ccc", "ddd", "eee");list.stream().filter(new Predicate<String>() {@Overridepublic boolean test(String s) {/*true:留下  false：舍棄*/return s.startsWith("a");}}).forEach(s -> System.out.println(s));/*簡化*/list.stream().filter(s -> s.startsWith("a")).forEach(s -> System.out.println(s));

• Limit 獲取前幾個元素，limit(個數(shù))

    /*limit獲取前幾元素，不是索引是元素*/list.stream().limit(4).forEach(s -> System.out.println(s));

• skip 跳過前幾個元素，skip(個數(shù))

  /*skip跳過前幾個元素*/list.stream().skip(2).forEach(s -> System.out.println(s));
  

  練習(xí)：

  /*練習(xí)獲取其中3-4*/list.stream().limit(4).skip(2).forEach(s -> System.out.println(s));System.out.println();list.stream().skip(2).limit(2).forEach(s -> System.out.println(s));System.out.println( );
  

  • distinct 去重復(fù)，在底層是hashset去重復(fù)

     /*去重復(fù)*/list1.stream().distinct().forEach(s -> System.out.println(s));/*引用數(shù)據(jù)類型可以直接，自定義的對象需要重寫hascode和equales方法*/

    

  • Concat 流合并
    **注意事項(xiàng)：**類型一致，不會提升類型，不一致會提升到倆流的父類，不能使用單獨(dú)流的特有功能

 /*流合并，類型一致，不會提升類型，不一致會提升到倆流的父類，不能使用單獨(dú)流的特有功能*/Stream.concat(list1.stream().distinct(),list.stream()).forEach(s -> System.out.println(s));

Map 流的轉(zhuǎn)換：

 /*流的轉(zhuǎn)換*/list2.stream().map(new Function<String, Integer>() {/*string表示流里面原來就有的數(shù)據(jù)* integer表示的是要轉(zhuǎn)換了之后的類型*/@Overridepublic Integer apply(String s) {String[] split = s.split("-");/*切割方法split*/String s1 = split[1];int i = Integer.parseInt(s1);/*integer中的轉(zhuǎn)換方法*/return i;}}).forEach(s -> System.out.println(s));System.out.println("================================");/*簡化*/list2.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(s-> System.out.println(s));

終結(jié)方法：

• 遍歷

/*遍歷方式*/list2.stream().forEach(s -> System.out.println(s));

• 統(tǒng)計

  /*將Stream流中的數(shù)據(jù)進(jìn)行統(tǒng)計*/System.out.println(list2.stream().distinct().count());
  

• 收集流中的數(shù)據(jù)放到數(shù)組中

    String[] array = list2.stream().toArray(new IntFunction<String[]>() {@Overridepublic String[] apply(int value) {return new String[value];}});System.out.println(Arrays.toString(array));/*簡化*/String[] array1 = list2.stream().toArray(value -> new String[value]);System.out.println(Arrays.toString(array));

• 收集流中的數(shù)據(jù)放到集合里面

  注意事項(xiàng)：

  lis集合是不會去重復(fù)的

  set集合是會去重復(fù)的

  map里面的鍵值對不能重復(fù)

  /*list*/List<String> collect = list2.stream().filter(s -> "男".equals(s.split("-")[2])).collect(Collectors.toList());System.out.println(collect);/*set*/Set<String> collect1 = list2.stream().filter(s -> "男".equals(s.split("-")[2])).collect(Collectors.toSet());System.out.println(collect1);/*迭代器遍歷*/Iterator<String> iterator = collect.iterator();while (iterator.hasNext()) {System.out.println(iterator.next());}/*增強(qiáng)for*/for (String s : collect) {System.out.println(s);}/*foreach*/collect.forEach((s)-> {  System.out.println(s); });/*收集到map集合當(dāng)中注意鍵值對不能重復(fù)*/Map<String, Integer> mapcollect = list2.stream().filter(s -> "男".equals(s.split("-")[2]))/*在map集合里面要傳遞2個數(shù)據(jù)，鍵的獲取規(guī)則，值的獲取規(guī)則*//*在鍵或者值里面有2個類型第一個表示流里面的類型，第二個表示鍵或者值里面的類型，他們是交叉對應(yīng)的*/.collect(Collectors.toMap(new Function<String, String>() {@Overridepublic String apply(String s) {return s.split("-")[0];}}, new Function<String, Integer>() {@Overridepublic Integer apply(String s) {return Integer.parseInt(s.split("-")[1]);}}));/*簡化*/Map<String, Integer> mapcollect2 = list2.stream().filter(s -> "男".equals(s.split("-")[2])).collect(Collectors.toMap(s -> s.split("-")[0],s -> Integer.parseInt(s.split("-")[1])));System.out.println(mapcollect2);System.out.println(mapcollect);
  

總結(jié)：