Java集合常用方法

List

ArrayList

Spliterator是在java 8引入的一个接口，它通常和stream一起使用，用来遍历和分割序列。

	public static void test() {

		
		/**
		 * 创建100个对象
		 */
		List<User> users = Stream.generate(() -> new User("1")).limit(100).collect(Collectors.toList());
		Spliterator<User> spliterator1 = users.spliterator();
		/**
		 * trySplit尝试对现有的stream进行分拆，一般用在parallelStream的情况，因为在并发stream下，
		 * 我们需要用多线程去处理stream的不同元素，trySplit就是对stream中元素进行分拆处理的方法。
		 */
		Spliterator<User> spliterator2 = spliterator1.trySplit();

		/**
		 * 表示待处理的元素
		 */
		System.err.println(spliterator1.estimateSize());
		
		/*
		  	表示Spliterator的特征: 共有八种特征
		 	public static final int ORDERED    = 0x00000010;//表示元素是有序的（每一次遍历结果相同）
			public static final int DISTINCT   = 0x00000001;//表示元素不重复
			public static final int SORTED     = 0x00000004;//表示元素是按一定规律进行排列（有指定比较器）
			public static final int SIZED      = 0x00000040;//
			表示大小是固定的
			public static final int NONNULL    = 0x00000100;//表示没有null元素
			public static final int IMMUTABLE  = 0x00000400;//表示元素不可变
			public static final int CONCURRENT = 0x00001000;//表示迭代器可以多线程操作
			public static final int SUBSIZED   = 0x00004000;//表示子Spliterators都具有SIZED特性
		 
		 */
		System.err.println(spliterator1.characteristics());
		/**
		 * 如果元素存在，则对他进行处理并返回true，负责返回false,类似集合的迭代器
		 */
		spliterator1.tryAdvance(System.err::println);
		/**
		 *  遍历
		 */
		spliterator1.forEachRemaining(System.err::println);
		
	}

	public static void listTest() {

		List<User> users = Stream.generate(() -> new User(new Integer((int) (Math.random() * 20)))).limit(20).collect(Collectors.toList());

		/**
		 * Comparator 外部比较器 Comparable 内部比较器
		 */
		users.sort(new Comparator<User>() {
			@Override
			public int compare(User u1, User u2) {
				if (u1.getId() < u2.getId()) {
					return 1;
				} else if (u1.getId() > u2.getId()) {
					return -1;
				}
				return 0;
			}

		});

		List<User> retainList = Stream.generate(() -> new User(new Integer((int) (Math.random() * 20)))).limit(3).collect(Collectors.toList());
		/**
		 * 只保留retainList集合中有的元素
		 */
		users.retainAll(retainList);
		/**
		 * 替换满足条件的元素
		 */
		users.replaceAll(a -> {
//			if (a.getUsername() == null) {
//				System.err.println("null");
//				a.setUsername("username");
//			}
			String uername = Optional.ofNullable(a.getUsername()).orElseGet(() -> new String("username"));
			a.setUsername(uername);
			return a;
		});
    }

LinkedList

        LinkedList<User> linkedList = new LinkedList<>();
		linkedList.add(new User(2));
		linkedList.add(new User(3));
		/**
		 * 最前面插入元素
		 */
		linkedList.addFirst(new User(1, "addFirst"));
		/**
		 * 倒序迭代器
		 */
		Iterator<User> descIterator = linkedList.descendingIterator();
		while (descIterator.hasNext()) {
			User user = (User) descIterator.next();
			System.err.println(user);
		}
		/**
		 * 检索但不删除此列表的头（第一个元素）
		 */
		User elementUser = linkedList.element();
		/**
		 * 添加指定元素作为此列表的尾部（最后一个元素）
		 */
		linkedList.offer(new User(4, "offer"));
		/**
		 * 删除此中指定元素的最后一个匹配项 列表（从头到尾遍历列表时）。如果列表不包含元素，它保持不变。
		 */
		linkedList.removeLastOccurrence(new User(4, "offer"));
		/**
		 * 检索并删除此列表的头（第一个元素）。
		 */
		linkedList.remove();
		/**
		 * 检索并删除此列表的头（第一个元素）。
		 */
		linkedList.poll();
		/**
		 * 检索并删除该列表的最后一个元素
		 */
		linkedList.pollLast();
		/**
		 * 检索但不删除此列表的头（第一个元素）。
		 */
		linkedList.peek();

交集、差集、并集

   public static void collectors() {

		List<String> list1 = Arrays.asList("a", "b", "c", "d");
		List<String> list2 = Arrays.asList("a", "b", "f");

		List<String> list3 = new ArrayList<>(list1);
		List<String> list4 = new ArrayList<>(list2);

		/**
		 * 差集
		 */
		List<String> difference = list4.stream().filter(s -> !list3.contains(s)).collect(Collectors.toList());
		difference.addAll(list3.stream().filter(s -> {
			return !list4.contains(s);
		}).collect(Collectors.toList()));

		/**
		 * 交集
		 */
		// list3.retainAll(list4);
		/**
		 * 并集
		 */
		list3.addAll(list4);
		List<String> union = list3.stream().distinct().collect(Collectors.toList());
		union.forEach(System.err::println);
		
		
		
	}