java 集合算法,相关知识点

集合算法

binarySearch

1. 使用前必须进行排序，否则结果不准确
2. 通过以下源码可以看出，要查询的key要和中间树进行比较如果小就往前查如果大就向后查，所以必须要排序，否则不管用
3. 倒序也不行，必须是正序，倒序比较的结果也不会准确

源码

    private static <T> int indexedBinarySearch(List<? extends Comparable<? super T>> list, T key) {
        int low = 0;
        int high = list.size()-1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            Comparable<? super T> midVal = list.get(mid);
            int cmp = midVal.compareTo(key);

            if (cmp < 0)
                low = mid + 1;
            else if (cmp > 0)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found
    }

示例代码

   		List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("Z");
        list.add("D");
        list.add("W");
        list.sort((o1,o2)->o1.compareToIgnoreCase(o2));
        int index = Collections.binarySearch(list, "Z");
        System.out.println(index);
        System.out.println(list);
        int index2 = Collections.binarySearch(list, "D", (o1,o2)->o1.compareToIgnoreCase(o2));
        System.out.println(index2);	

输出

4
[A, B, D, W, Z]
2

checkedCollection

1. 返回运行时安全视图

   List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("Z");
        list.add("D");
        list.add("W");
        
        Collection<String> cc = Collections.checkedCollection(list, String.class);
        System.out.println(cc);
        cc.remove("A");
        System.out.println(cc);
        System.out.println(list);

        //输出
        //[A, B, Z, D, W]
		//[B, Z, D, W]
		//[B, Z, D, W]

copy

源码

   public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        int srcSize = src.size();
        if (srcSize > dest.size())
            throw new IndexOutOfBoundsException("Source does not fit in dest");

        if (srcSize < COPY_THRESHOLD ||
            (src instanceof RandomAccess && dest instanceof RandomAccess)) {
            for (int i=0; i<srcSize; i++)
                dest.set(i, src.get(i));
        } else {
            ListIterator<? super T> di=dest.listIterator();
            ListIterator<? extends T> si=src.listIterator();
            for (int i=0; i<srcSize; i++) {
                di.next();
                di.set(si.next());
            }
        }
    }

从上面的源码可以看出被复制的list必须要有长度，否则就会抛出异常

复制后是有了一个新的集合，修改其中一个集合内容不会影响其他集合

代码示例

 public void test4(){
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("Z");
        list.add("D");
        list.add("W");
        
        List<String> list1 = new ArrayList<>(Arrays.asList(new String[list.size()]));
        Collections.copy(list1, list);
        System.out.println(list);
        System.out.println(list1);
        list1.remove(2);
        list1.set(0, "A-new");
        System.out.println(list);
        System.out.println(list1);
    }
    //输出
     /*  [A, B, Z, D, W]
        [A, B, Z, D, W]
        [A, B, Z, D, W]
        [A-new, B, D, W]*/

disjoint

1. 两个集合是否含有公共元素
2. 包含为false 不包含为true

 public void test5() {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("Z");
        list.add("D");
        list.add("W");
        
        List<String> list1 = new ArrayList<>();
        list1.add("AX");
        list1.add("AA");
        
        boolean boo = Collections.disjoint(list, list1);
        System.out.println(boo);
        //输出
        //true
        
    }

emptyList

1. 获取一个空集合
2. 不可变 不可添加元素
3. 可以理解成一个空列表的标识

 List<String> list = Collections.emptyList();
       // list.add("A");
        System.out.println(list);

fill

 public static <T> void fill(List<? super T> list, T obj)

1. 将obj赋给集合每一个元素

       List<String> list = new ArrayList<>();     
        list.add("A");       
        list.add("B");       
       list.add("Z");       
       list.add("D");       
       list.add("W");      
      String name ="zhangsan"; 
         
       Collections.fill(list, name);        
       list.forEach((e)->System.out.println(e));
       
               //        zhangsan		
               //        zhangsan		
               //        zhangsan		
               //        zhangsan		
               //        zhangsan

frequency

1.计算元素出现的次数并返回结果

  public void test8() {        
  List<String> list = new ArrayList<>();        
  list.add("A");        
  list.add("B");        
  list.add("Z");        
  list.add("D");        
  list.add("W");        
  list.add("A");        
  list.add("A");        
  list.add("W");        
  System.out.println(Collections.frequency(list, "A"));  
   System.out.println(Collections.frequency(list, "Z"));   
   }

indexOfSubList lastIndexOfSubList

1. 第一次出现和最后一次出现的位置

   List<String> list = new ArrayList<>();        list.add("A");        list.add("B");        list.add("Z");        list.add("D");        list.add("W");        list.add("A");        list.add("B");        list.add("W");                List<String> list1 = new ArrayList<>();        list1.add("A");        list1.add("B");                System.out.println(Collections.indexOfSubList(list, list1));        System.out.println(Collections.lastIndexOfSubList(list, list1));

max min

1. 找出最大最小的元素

 public void test10() {       
  List<String> list = new ArrayList<>();       
   list.add("A");        
   list.add("B");        
   list.add("Z");       
    list.add("D");        
    list.add("W");        
    list.add("A");        
    list.add("B");        
    list.add("W");                
    List<String> list1 = new ArrayList<>();        
    list1.add("A");       
     list1.add("B");       
      System.out.println(
      Collections.max(list, (o1,o2)->o2.compareToIgnoreCase(o1)));
              
              //不排序使用自然顺序
    System.out.println(Collections.max(list));     
    //min 方法同理不再演示    
    }
    //输出//A//Z

nCopies

1. 返回一个集合的不可变副本，不允许增删改查

      List<String> list = Collections.nCopies(10, "A");        System.out.println(list);        /*list.add("B");        System.out.println(list);        list.set(5, "Z");        System.out.println(list);*/        //输出        //[A, A, A, A, A, A, A, A, A, A]

replaceAll

 List<String> list = new ArrayList<>();        
 list.add("A");        
 list.add("B");       
  list.add("Z");        
  list.add("D");        
  list.add("W");        
  list.add("A");        
  list.add("B");        
  list.add("W");        
  Collections.replaceAll(list, "A", "a"); 
  System.out.println(list);        
  //[a, B, Z, D, W, a, B, W]

reverse rotate shuffle

1. 颠倒,旋转，搅乱 元素顺序

       List<String> list = new ArrayList<>();        
       list.add("A");        
       list.add("B");        
       list.add("Z");        
       list.add("D");        
       list.add("W");        
       list.add("A");        
       list.add("B");        
       list.add("W");        
       //翻转        
       System.out.println(list);        
       //[A, B, Z, D, W, A, B, W]        
       Collections.reverse(list);        
       System.out.println(list);        
       //[W, B, A, W, D, Z, B, A]                
       //旋转        
       /**         
       * 向右旋转 将最后指定的元素拿到前面来         
       * * 传值为负 就是向左旋转        
       *  */       
       Collections.rotate(list, 2);        
       System.out.println(list);        
       //[B, A, W, B, A, W, D, Z]               
       /**         
       * * 搅乱集合的元素         
       * *          
       * */        
       List<Integer> nums = new ArrayList<>();       
       nums.add(100);        
       nums.add(20);        
       nums.add(1);       
        
       nums.add(34);        
       System.out.println(nums);        
       Collections.shuffle(nums, new Random(1));  
       System.out.println(nums);      
       Collections.shuffle(nums);      
       System.out.println(nums);
             
             //        [100, 20, 1, 34]
             //        [34, 100, 20, 1]
             //        [1, 34, 20, 100]

singleton singletonList

1. 不可变集合
2. 只含有一个元素

  List<String> list = Collections.singletonList("A");
  Set<Integer> set = Collections.singleton(100);  
  System.out.println(list);       
  System.out.println(set);       // [A]       //[100]

sort

   public void test15() {        
   		List<Integer> list = new ArrayList<>();        
   		list.add(100);        
   		list.add(20);        
   		list.add(25);        
   		Collections.sort(list);        
   		System.out.println(list);        
   		Collections.sort(list, (o1,o2)->o2-o1); 
   	System.out.println(list);    
   	}

swap 位置交换

public void test16() {        
List<String> list = new ArrayList<>();  
      
list.add("A");        
list.add("B");        
list.add("C");        
Collections.swap(list, 0, 2);        
System.out.println(list);        //[C, B, A]    
}

synchronizedList 线程安全的集合的地址

    public void test17() {        
    List<String> list = new ArrayList<>();        
    list.add("A");        
    list.add("B");        
    list.add("C");        
    List<String> list1 = Collections.synchronizedList(list);   
    System.out.println(list1);        
    list.set(1, "V");        
    System.out.println(list1);      
     System.out.println(list);    }

unmodifiableList 不可修改的集合副本

1.不能进行增删改查

  List<String> list = new ArrayList<>();       
   list.add("A");        
   list.add("B");       
   list.add("C");                
   List<String> list2 = Collections.unmodifiableList(list);   
   System.out.println(list2);