Java实用小技能之快速创建List常用几种方式

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);

List<String> excludeFields = Arrays.asList("secretKey","privateKey","publicKey");
//这种方式构造的 List 是固定长度的，如果调用 add 方法增加新的元素时会报异常 java.lang.UnsupportedOperationException。

List<Integer> list = Arrays.asList(1, 2, 3);
list = new ArrayList<>(list);
list.add(4);

List<Integer> list = Stream.of(1, 2, 3).collect(Collectors.toList());

List<Integer> list= new ArrayList() {{
    add(1);
    add(2);
    add(3);
}};

List<Integer> list = CollectionUtil.newArrayList(1, 2, 3);

import com.google.common.collect.Lists;
 
List<Integer> list = Lists.newArrayList(1, 2, 3);

List<Integer> list = Lists.newArrayList(1, 2, 3);

List<Integer> list = List.of(1,2,3);

public class IteratorDemo{
    public static void main(String[] args){
        List l=new ArrayList();
        l.add("abc");
        l.add("123");
        l.add("中国");
        Iterator it=L.iterator();
    }
}

package com.csuinfosoft.grammer.ListDemo;
 
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
 
/**
 * 
 * @author iOS逆向
 * @date 上午8:32:37
 * ArrayList和LinedList都实现了List接口，但LinkedList还实现了Queue和Deque接口，
 * 可以用作队列和栈。(其中在jdk6.0,LinkedList才实现Deque接口)
 */
public class LinkedListOfqueue {
	public static void main(String[] args) {
		Queue queue=new LinkedList();
		//入队
		queue.offer("A");// boolean offer(E o) 如果可能，将指定的元素插入此队列 
		queue.offer("B");
		queue.offer("C");
		//出队
		System.out.println(queue.poll());// E poll() 检索并移除此队列的头，如果此队列为空，则返回 null。
		System.out.println(queue.poll());
		Deque stack=new LinkedList();
		//入栈
		stack.push("A");//void push(E e)将一个元素推入此双端队列所表示的堆栈（换句话说，此双端队列的头部），如果可以直接这样做而不违反容量限制的话；
		//如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。 
		stack.push("B");
		stack.push("C");
		//出栈
		System.out.println(stack.pop());// E pop() 从此双端队列所表示的堆栈中弹出一个元素。
		System.out.println(stack.pop());
	}
}
 queue=new LinkedList();
		//入队
		queue.offer("A");// boolean offer(E o) 如果可能，将指定的元素插入此队列 
		queue.offer("B");
		queue.offer("C");
		//出队
		System.out.println(queue.poll());// E poll() 检索并移除此队列的头，如果此队列为空，则返回 null。
		System.out.println(queue.poll());
		Deque stack=new LinkedList();
		//入栈
		stack.push("A");//void push(E e)将一个元素推入此双端队列所表示的堆栈（换句话说，此双端队列的头部），如果可以直接这样做而不违反容量限制的话；
		//如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。 
		stack.push("B");
		stack.push("C");
		//出栈
		System.out.println(stack.pop());// E pop() 从此双端队列所表示的堆栈中弹出一个元素。
		System.out.println(stack.pop());
	}
}

package zx.callback;
public class Test {
 
	/**
	 * @param args
	 * @return void
	 */
	public static void main(String[] args) {
		  //实例化一个讲师
		TeacherPro2 pro=new TeacherPro2("kunnan");
		//作为程序员工作
		pro.work(); //调用继承的方法
		//作为老师工作
		pro.asTeacher().work();//使用内部类来解决接口方法被替换的问题
		//pro.asTeacher()由pro创建，pro.asTeacher()的work()方法调用了pro的teach方法。体现了回调功能。
	}
}

package zx.callback;
 
public interface Teacher {
   void work();//定义工作
}

package zx.callback;
 
/**
 * 程序员
 * 
 * @author zhang_kn
 *
 */
public class Programmer {
	private String name;
 
	public Programmer() {
 
	}
 
	public Programmer(String name) {
		super();
		this.name = name;
	}
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
 
	public void work() {
		System.out.println("天天写代码，天天需求被改。。ios。");
	}
}

package zx.callback;
 
public class TeacherPro2 extends Programmer {
	// 定义一个方法作为教师的职责授课，使用private修饰
	private void teach() {
		System.out.println("讲课。。。");
	}
	// 提供内部类,使用private修饰
	private class Coust implements Teacher {
		public void work() {//避免与TeacherPro2 继承的work方法重复
			teach();//执行教师的职责。使用TeacherPro2 的资源teach。体现了回调模式。
		}
	}
	public Teacher asTeacher() {//提供给外界获取包含老师功能的实现类的接口
		return new Coust();
	}
	
	public TeacherPro2() {
		super();
	}
	public TeacherPro2(String name) {
		super(name);
 
	}
}