vlambda博客
学习文章列表

  
    
    
  

   
     
     
   
1LinkedList<Integer> lists = new LinkedList<>();
 2
 3lists.addFirst(1);
 4lists.push(2);
 5lists.addLast(3);
 6lists.add(4);
 7lists.addFirst(5);
 8
 9lists.forEach(System.out::println);
10// 5 2 1 3 4
  
    
    
  

  
    
    
  

   
     
     
   
1List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
2integers.set(2, 5); // 这个操作可以
3//integers.add(6); 这个会抛出异常
4integers.forEach(System.out::println); // 1 2 5 4 5
5
6 1. 很显然我们是可以修改 list集合的 可以使用set方法
7 2. 但是当我们尝试去使用add() 方法时,会抛出 java.lang.UnsupportedOperationException 的异常,
8不支持操作的异常
9 3.当我们使用 java9+时 可以使用 List.of()方法 ,他就是彻彻底底的不可修改的
  
    
    
  
  
    
    
  

   
     
     
   

  
    
    
  

  
    
    
  

   
     
     
   
1 1. 使用 Collections这个工具类
2List<Integer> integers1 = Collections.synchronizedList(integers);
3
4 2. java5+ 变成 CopyOnWriteArrayList
5CopyOnWriteArrayList<Integer> integers2 = (CopyOnWriteArrayList<Integer>) integers;
6
7 3. java9+ ,使用 List.of() 变成只读对象
  
    
    
  

  
    
    
  

   
     
     
   
 1 1. 创建一个安全的空集合,防止NullPointerException异常
 2List<String> list = Collections.<String>emptyList();
 3
 4 2. 拷贝集合
 5Collections.addAll(list, 2,3, 4, 5, 6);
 6
 7 3. 构建一个安全的集合
 8List<Integer> safeList = Collections.synchronizedList(list);
 9
10 4. 二分查找
11Collections.binarySearch(list, 2);
12
13 5.翻转数组
14Collections.reverse(list);
  
    
    
  


  
    
    
  

   
     
     
   

  
    
    
  
  
    
    
  

   
     
     
   

  
    
    
  

  
    
    
  

   
     
     
   
1public CopyOnWriteArraySet() {
2     al = new CopyOnWriteArrayList<E>();
3 }
  
    
    
  

  
    
    
  

   
     
     
   
1public static void main(String[] args) {
 2    Queue<Integer> queue = new LinkedList<>();
 3
 4    queue.offer(1);
 5    queue.offer(2);
 6    queue.offer(3);
 7
 8    System.out.println(queue.poll());
 9    System.out.println(queue.poll());
10    System.out.println(queue.poll());
11}
12// 1, 2 , 3
  
    
    
  


  
    
    
  

   
     
     
   

  
    
    
  

  
    
    
  

   
     
     
   
1@Test
 2public void testLinkedList() throws InterruptedException {
 3
 4    DelayQueue<Person> queue = new DelayQueue<>();
 5
 6    queue.add(new Person());
 7
 8    System.out.println("queue.poll() = " + queue.poll(200,TimeUnit.MILLISECONDS));
 9}
10
11
12static class Person implements Delayed {
13
14    @Override
15    public long getDelay(TimeUnit unit) {
16        // 这个对象的过期时间
17        return 100L;
18    }
19
20    @Override
21    public int compareTo(Delayed o) {
22        //比较
23        return o.hashCode() - this.hashCode();
24    }
25}
26
27输出 : 
28queue.poll() = null
  
    
    
  


  
    
    
  

   
     
     
   

  
    
    
  

  
    
    
  

   
     
     
   
1private static final int NOW = 0; // for untimed poll, tryTransfer(不阻塞)
2private static final int ASYNC = 1; // for offer, put, add(不阻塞)
3private static final int SYNC = 2; // for transfer, take(阻塞)
4private static final int TIMED = 3; // for timed poll, tryTransfer (waiting)
  
    
    
  

  
    
    
  

   
     
     
   
1/**
 2 * 构建一个 大顶堆
 3 *
 4 * @param tree
 5 * @param n
 6 */
 7static void build_heap(int[] tree, int n) {
 8
 9    // 最后一个节点
10    int last_node = n - 1;
11
12    // 开始遍历的位置是 : 最后一个堆的堆顶 , (以最小堆为单位)
13    int parent = (last_node - 1) / 2;
14
15    // 递减向上遍历
16    for (int i = parent; i >= 0; i--) {
17        heapify(tree, n, i);
18    }
19}
20
21
22/**
23 * 递归操作
24 * @param tree 代表一棵树
25 * @param n 代表多少个节点
26 * @param i 对哪个节点进行 heapify
27 */
28static void heapify(int[] tree, int n, int i) {
29
30    // 如果当前值 大于 n 直接返回了 ,一般不会出现这种问题 .....
31    if (i >= n) {
32        return;
33    }
34
35    // 子节点
36    int c1 = 2 * i + 1;
37    int c2 = 2 * i + 2;
38
39    // 假设最大的节点 为 i (父节点)
40    int max = i;
41
42    // 如果大于 赋值给 max
43    if (c1 < n && tree[c1] > tree[max]) {
44        max = c1;
45    }
46
47    // 如果大于 赋值给 max
48    if (c2 < n && tree[c2] > tree[max]) {
49        max = c2;
50    }
51
52    // 如果i所在的就是最大值我们没必要去做交换
53    if (max != i) {
54
55        // 交换最大值 和 父节点 的位置
56        swap(tree, max, i);
57
58        // 交换完以后 , 此时的max其实就是 i原来的数 ,就是最小的数字 ,所以需要递归遍历
59        heapify(tree, n, max);
60    }
61
62}
63
64// 交换操作
65static void swap(int[] tree, int max, int i) {
66    int temp = tree[max];
67    tree[max] = tree[i];
68    tree[i] = temp;
69}
  
    
    
  


  
    
    
  

   
     
     
   

  
    
    
  

  
    
    
  

   
     
     
   
1@Test
 2public void testStack() {
 3
 4    Stack<Integer> stack = new Stack<>();
 5
 6    // push 添加
 7    stack.push(1);
 8
 9    stack.push(2);
10
11    // pop 返回栈顶元素 , 并移除
12    System.out.println("stack.pop() = " + stack.pop());
13
14    System.out.println("stack.pop() = " + stack.pop());
15
16}
17
18输出 : 
192 , 1
  
    
    
  


  
    
    
  

   
     
     
   -End-
   
     
     
   

  
    
    
  

   
     
     
   

    
      
      
    
   
     
     
   
   
     
     
   

    
      
      
    
 
    
   
     
     
   

   
     
     
   

    
      
      
    
 
     
 
      
 
       
 
        
 
         
 
          
 
           
 
            
 
             
 
              
 
                可乐记得加冰，爱我就要置顶  
               
 
              
 
             
 
             
 
              
 
              
 
             
 
            
 
           
 
          
 
         
 
        
 
       
 
      
 
     
 
     
 
      
 
       
 
        
 
         
 
         
 
        
 
       
 
      
 
     
 
    
    
      
      
    
 
     
 
      
 
       
 
        客官！在看一下呗