section.java.util.data.xml

<?xml version="1.0" encoding="UTF-8"?>
<chapter id="index"><?dbhtml dir="structures" ?>
	<title>数据结构</title>
	<screen>
		<![CDATA[
Collection
 ├List
 │├LinkedList
 │├ArrayList
 │└Vector
 │　└Stack
 └Set
		]]>
	</screen>
	<section id="Collection">
		<title>Collection 接口</title>
		<screen>
		<![CDATA[
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个 Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后 一个构造函数允许用户复制一个Collection。
　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
　　　　Iterator it = collection.iterator(); // 获得一个迭代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一个元素
　　　　}
由Collection接口派生的两个接口是List和Set。		
		]]>
		</screen>
		<screen>
		<![CDATA[
List接口
　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
　　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素， 还能向前或向后遍历。
　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。
LinkedList类
　　LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
　　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));
ArrayList类
　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
　　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法 并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
　　和LinkedList一样，ArrayList也是非同步的（unsynchronized）。
Vector类
　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和 ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了 Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出 ConcurrentModificationException，因此必须捕获该异常。
Stack 类
　　Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop 方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。
Set接口
　　Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
　　很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
　　请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。
Map接口
　　请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个 value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。		
		]]>
		</screen>
	</section>
	<section id="java.util.List">
		<title>List</title>


		<programlisting>
		<![CDATA[
package cn.netkiller.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.TreeSet;

public class Test {

	public Test() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		// A A B E F G C D
		String[] array = { "A", "A", "B", "E", "F", "G", "C", "D" };
		Collection<String> list = new ArrayList<String>(Arrays.asList(array));
		for (String str : list) {
			System.out.print(str + " ");
		}
		System.out.println();

		// A A B E F G C D
		Collection<String> linkedList = new LinkedList<String>(Arrays.asList(array));
		for (String str : linkedList) {
			System.out.print(str + " ");
		}
		System.out.println();

		// 无重复，无序 D E F G A B C
		Collection<String> hashSet = new HashSet<String>(Arrays.asList(array));
		for (String str : hashSet) {
			System.out.print(str + " ");
		}
		System.out.println();

		// 无重复 A B C D E F G
		Collection<String> treeSet = new TreeSet<String>(Arrays.asList(array));
		for (String str : treeSet) {
			System.out.print(str + " ");
		}
		System.out.println();

		// 无重复 A B E F G C D
		Collection<String> linkedHashSet = new LinkedHashSet<String>(Arrays.asList(array));
		for (String str : linkedHashSet) {
			System.out.print(str + " ");

		}

	}

}
		]]>
		</programlisting>
		<para>输出结果</para>
		<screen>
			A A B E F G C D
			A A B E F G C D
			A B C D E F G
			A B C D E F G
			A B E
			F G C D
		</screen>
		<section>
			<title>静态 List</title>
			<programlisting>
			<![CDATA[
	public static List<String> list = new ArrayList<String>();
	static {
		list.add("录入");
		list.add("变更");
		list.add("收藏");
		list.add("在售");
		list.add("展出");
	}			
				
			]]>
			</programlisting>
		</section>



		<section id="List.of()">
			<title>List.of()</title>
			<programlisting>
		<![CDATA[
List<String> strings = List.of("first", "second");		
		]]>
			</programlisting>
		</section>
		<section id="List.copyOf()">
			<title>List.copyOf()</title>
			<screen>
			<![CDATA[
var list = List.of("Java", "Python", "C");
var copy = List.copyOf(list);
System.out.println(list == copy); // true
			]]>
			</screen>
			<programlisting>
		<![CDATA[
var list = new ArrayList<String>();
var copy = List.copyOf(list);
System.out.println(list == copy); // false
		]]>
			</programlisting>
		</section>
		<section id="Arrays.asList">
			<title>String[] to List</title>
			<programlisting>
		<![CDATA[
String[] arr = new String[] {"1", "2"};
List list = Arrays.asList(arr);		
		]]>
			</programlisting>
		</section>
		<section id="Collectors.toList">
			<title>Stream.toList() 方法</title>
			<para>数组转List</para>
			<programlisting>
			<![CDATA[
String[] arrays = {"tom", "jack", "kate"};
List<String> stringList= Stream.of(arrays).collect(Collectors.toList());			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
package cn.netkiller.demo;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class TestList {

	public TestList() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {

		List<String> list = Arrays.asList("1", "2", "3");
		// jdk11 之前这样写
		List<Integer> list1 = list.stream().map(Integer::parseInt).collect(Collectors.toList());
		System.out.println(list1);
		// jdk16 现在可以这样写
		List<Integer> list2 = list.stream().map(Integer::parseInt).toList();
		System.out.println(list2);

	}
}			
			]]>
			</programlisting>
		</section>
		<section id="list.containsAll">
			<title>containsAll</title>
			<programlisting>
			<![CDATA[
        List<String> inputStringList = Arrays.asList("Neo|Netkiller|Tom|Jerry".split("|"));
        List<String> wordsList = Arrays.asList("Neo|Tom".split("|"));
        System.out.println(inputStringList.containsAll(wordsList));			
			]]>
			</programlisting>
		</section>
		<section>
			<title></title>
			<section>
				<title>过滤</title>

				<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.util.Arrays;
import java.util.List;

public class Test {


    public static void main(String[] args) throws InterruptedException {

        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 创建一个流并过滤出长度大于4的名字，然后打印
        names.stream()
                .filter(name -> name.length() > 4)
                .forEach(System.out::println);

    }

}			
			]]>
				</programlisting>
			</section>
			<section id="stream.allMatch">
				<title>stream().allMatch()</title>
				<programlisting>
			<![CDATA[
        List<String> inputStringList = Arrays.asList("Neo|Netkiller|Tom|Jerry".split("|"));
        List<String> wordsList = Arrays.asList("Neo","Tom");
        System.out.println(wordsList.stream().allMatch(inputStringList::contains));			
			]]>
				</programlisting>
			</section>
		</section>
		<section id="随机获取List元素">
			<title>随机 List</title>
			<programlisting>
			<![CDATA[
List<String> list = Arrays.asList("a","b","c");
int index = (int) (Math.random()* list.size());
System.out.println(list.get(index));			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class RandomListElement {
    public static void main(String[] args) {
        // 初始化一个列表
        List<String> list = new ArrayList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");
        list.add("元素4");
        list.add("元素5");

        // 方法1：使用 Random 类
        Random random = new Random();
        String randomElement1 = list.get(random.nextInt(list.size()));
        System.out.println("随机选取的元素 (使用 Random): " + randomElement1);

        // 方法2：使用 ThreadLocalRandom (Java 8+)
        String randomElement2 = list.get(
                java.util.concurrent.ThreadLocalRandom.current().nextInt(list.size())
        );
        System.out.println("随机选取的元素 (使用 ThreadLocalRandom): " + randomElement2);
    }
}			
			]]>
			</programlisting>
		</section>
		<section id="getFirst">
			<title>getFirst() / getLast()</title>
			<para>使用 idea 写代码，list 变量可以看到 getFirst() / getLast() 但实际上 list
				并没有两个方法，这时 idea 模版造成的。
			</para>
			<screen>
			<![CDATA[
java: 找不到符号
  符号:   方法 getFirst()
  位置: 类型为java.util.ArrayList<java.lang.String>的变量 list			
			]]>
			</screen>

			<programlisting>
			<![CDATA[
        // 创建一个ArrayList对象
        ArrayList<String> list = new ArrayList<>();

        // 添加元素到列表中
        list.add("apple");
        list.add("banana");
        list.add("orange");

        // 获取最后一个元素
//        String firstElement = list.getFirst();
//        String lastElement = list.getLast();
        String lastElement = list.get(list.size() - 1);
        System.out.println("最后一个元素是：" + lastElement);			
			]]>
			</programlisting>
		</section>
		<section id="List.toArray">
			<title>List 转 Array</title>
			<programlisting>
			<![CDATA[
        List<CompletableFuture<String>> completableFutures = Stream.of(future1, future2, future3).toList();
        CompletableFuture[] completableFutureArray = completableFutures.toArray(CompletableFuture[]::new);			
			
		List<CompletableFuture<String>> completableFutures = Stream.of(future1, future2, future3).toList();
        var completableFutureArray = completableFutures.toArray(CompletableFuture[]::new);
			]]>
			</programlisting>
		</section>
	</section>

	<section id="ArrayList">
		<title>ArrayList</title>
		<section>
			<title>初始化</title>
			<para>最常用的初始化方式,先创建一个list1，再给list1赋值。</para>
			<programlisting>
			<![CDATA[
List<String> list1 = new ArrayList<String>();
list1.add("apple");
list1.add("banana");
list1.add("orange");
			]]>
			</programlisting>
			<para>使用一个List来初始化</para>
			<programlisting>
			<![CDATA[
List<String> list2 = new ArrayList<String>(Arrays.asList("apple", "banana", "orange"));			
			]]>
			</programlisting>
			<para></para>
			<programlisting>
			<![CDATA[
List<String> list3 = new ArrayList<String>(Collections.nCopies(2, "orange"));
			]]>
			</programlisting>
			<para>使用匿名内部类来初始化</para>
			<programlisting>
			<![CDATA[
List<String> list4 = new ArrayList<String>() {
     {
         add("apple");
         add("banana");
         add("orange");
     }
}; 	
			]]>
			</programlisting>
			<para>初始化容量 initialCapacity</para>
			<programlisting>
			<![CDATA[
        List<String> test = new ArrayList<>(5);
        IntStream.range(1, 10).forEach(value -> {
            test.add(String.valueOf(value));
        });
        System.out.println(test);			
			]]>
			</programlisting>
		</section>
		<section>
			<title>判断元素是否存在</title>
			<para>判断元素是否存在</para>
			<programlisting>
		<![CDATA[
import java.util.ArrayList;

public class arraylist {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList<String> whitelist = new ArrayList<String>();
		whitelist.add("Neo");
		whitelist.add("Jam");
		whitelist.add("Sam");

		if (whitelist.contains("Neo")) {
			System.out.println("Found!");
		}else{
			System.out.println("Not Found!");
		}
	}

}
		]]>
			</programlisting>
		</section>

		<section>
			<title>循环打印</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.type;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ArrayListExample {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> list = new ArrayList<String>();
		list.add("Jack");
		list.add("Jet");
		list.add("Jack");
		list.add("Mike");
		list.add("Kitty");
		list.add("Tom");
		
		//while 循环
		Iterator<String> it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}

		for (Iterator<String> it1 = list.iterator(); it1.hasNext();) {
			System.out.println(it1.next());
		}

		// for 循环
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}

		// for 循环加强版
		for (String i : list) {
			System.out.println(i);
		}

	}

}
			]]>
			</programlisting>
		</section>
		<section>
			<title>ArrayList to Array</title>
			<para>ArrayList 转为 Array</para>
			<programlisting>
			<![CDATA[
		String[] array = {"/bin/sh","-c"};
		List<String> list = new ArrayList<String>(Arrays.asList(array));
	    list.add("command");
	    list.add("param");
	   
	    String[] command = (String[]) list.toArray(new String[0]);
	    System.out.println(Arrays.toString(command));
			]]>
			</programlisting>

		</section>
		<section>
			<title>ArrayList to String</title>
			<programlisting>
				<![CDATA[
		List<String> list = new ArrayList<String>();
	    list.add("command");
	    list.add("param");
	   
	    String listString = String.join(", ", list);
	    
	    System.out.println(listString);
	    		]]>
			</programlisting>
		</section>

		<section>
			<title>Array to List</title>
			<programlisting>
			<![CDATA[
Arrays.asList(array)			
			]]>
			</programlisting>
		</section>
		<section>
			<title>List to Array</title>
			<programlisting>
				<![CDATA[
		List<String> list = new ArrayList<String>();
		list.add("str1");
		list.add("str2");

		String[] array = (String[]) list.toArray();
		System.out.println(array);				
				]]>
			</programlisting>
		</section>
		<section id="arrayList.forEach">
			<title>ArrayList forEach</title>
			<programlisting>
		<![CDATA[ 
// create an ArrayList which going to
// contains a list of Numbers
ArrayList<Integer> Numbers = new ArrayList<Integer>();

// Add Number to list
Numbers.add(23);
Numbers.add(32);
Numbers.add(45);
Numbers.add(63);

// forEach method of ArrayList and
// print numbers
Numbers.forEach((n) -> System.out.println(n));		
		]]>
			</programlisting>
			<programlisting>
		<![CDATA[ 
import java.util.*;
public class ArrayListTest {
	
	public static void main(String[] args)
	{
		// create an ArrayList which going to
		// contains a list of Student names which is actually
		// string values
		ArrayList<String> students = new ArrayList<String>();
	
		// Add Strings to list
		// each string represents student name
		students.add("Ram");
		students.add("Mohan");
		students.add("Sohan");
		students.add("Rabi");
	
		// print result
		System.out.println("list of Students:");
	
		// forEach method of ArrayList and
		// print student names
		students.forEach((n) -> print(n));
	}
	
	// printing student name
	public static void print(String n)
	{
		System.out.println("Student Name is " + n);
	}
}		
		]]>
			</programlisting>
			<programlisting>
		<![CDATA[
List<String> arrayList = new ArrayList<>();
arrayList.add("A");
arrayList.add("B");
arrayList.add("C");
arrayList.add("D");
arrayList.add("E");

for (String item:arrayList){
    System.out.println(item);
}

arrayList.forEach(item->System.out.println(item));

arrayList.forEach(System.out::println);

arrayList.forEach(item->{
    if("C".equals(item)){
        System.out.println(item);
    }
});		
		]]>
			</programlisting>
			<programlisting>
		<![CDATA[ 
package cn.netkiller;

import java.util.ArrayList;
import java.util.List;

public class Test {

	public Test(int id) {
		this.id = id;
	}

	public int id;
	public String name;

	public void setId(int id) {
		this.id = id;
	}

	public int getId() {
		return this.id;
	}

	public static void main(String[] args) throws InterruptedException {
		List<Test> arrayList = new ArrayList<Test>();
		arrayList.add(new Test(1));
		arrayList.add(new Test(2));
		arrayList.add(new Test(3));
		arrayList.add(new Test(4));
		arrayList.add(new Test(5));

		arrayList.forEach(item -> {
			System.out.println(item.getId());
			item.setId(item.getId() + 1);
		});

		arrayList.forEach(item -> {
			System.out.println(item.getId());
		});
	}

}				
		]]>
			</programlisting>
		</section>
		<section id="ArrayList.stream()">
			<title>ArrayList stream()</title>
			<programlisting>
		<![CDATA[
arrayList.stream()
        .filter(s-> s.contains("B")||s.contains("C"))
        .forEach(System.out::println);

arrayList.stream()
        .filter(s->s.contains("E"))
        .findFirst().ifPresent(s -> System.out.println(s));		
		]]>
			</programlisting>
		</section>
		<section id="ArrarList2String">
			<title>ArrarList 转换为 string[]</title>
			<programlisting>
		<![CDATA[
　　ArrayList list = new ArrayList();

　　list.Add("aaa");

　　list.Add("bbb");

　　string[] arrString = (string[])list.ToArray(typeof( string)) ;		
		]]>
			</programlisting>
		</section>
		<section id="StringToArrayList">
			<title>string 转换为 ArrayList</title>
			<programlisting>
		<![CDATA[
　　String str="1,2,3,4,5";
　　ArrayList b = new ArrayList( str.split(',') ) ;		
		]]>
			</programlisting>
		</section>
		<section>
			<title>ArrayList 转换为 string</title>
			<programlisting>
		<![CDATA[
　　ArrayList list = new ArrayList();

　　list.Add("aaa");

　　list.Add("bbb");

　　string str= string.Join(",", (string[])list.ToArray(typeof( string)));		
		]]>
			</programlisting>
		</section>
		<section>
			<title>string[] 转换为 ArrarList</title>
			<programlisting>
		<![CDATA[
　　ArrayList list = new ArrayList(new string[] { "aaa", "bbb" });		
		]]>
			</programlisting>
		</section>
		<section>
			<title><![CDATA[合并 List<byte[]> ArrayList<byte[]>]]></title>
			<programlisting>
			<![CDATA[
        List<byte[]> audios = new ArrayList<byte[]>();

        public static byte[] concatenateByteArrays(List<byte[]> byteArrays) {
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

            for (byte[] byteArray : byteArrays) {
                try {
                    outputStream.write(byteArray);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            return outputStream.toByteArray();
        }			
			]]>
			</programlisting>
		</section>
	</section>
	<section id="LinkedList">
		<title>LinkedList</title>
		<para>链表（Linked list）是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址</para>
		<para>初始化</para>
		<programlisting>
		<![CDATA[
        LinkedList<Integer> sequence = new LinkedList<>() {{
            push(10);
            push(50);
            push(100);
            push(1000);
        }};		
		]]>
		</programlisting>
		<programlisting>
		<![CDATA[
package cn.netkiller.test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class Test {

    public static void main(String[] args) {
        Test test = new Test();
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        LinkedList<Integer> linkedList = new LinkedList<Integer>();
        int size = 10000 * 1000;
        int index = 5000 * 1000;

        System.out.println("arrayList add " + size);
        addData(arrayList, size);
        System.out.println("linkedList add " + +size);
        addData(linkedList, size);
        System.out.println();

        System.out.println("arrayList get " + index + " th");
        getIndex(arrayList, index);
        System.out.println("linkedList get " + index + " th");
        getIndex(linkedList, index);
        System.out.println();

        System.out.println("arrayList set " + index + " th");
        setIndex(arrayList, index);
        System.out.println("linkedList set " + index + " th");
        setIndex(linkedList, index);
        System.out.println();

        System.out.println("arrayList add " + index + " th");
        addIndex(arrayList, index);
        System.out.println("linkedList add " + index + " th");
        addIndex(linkedList, index);
        System.out.println();

        System.out.println("arrayList remove " + index + " th");
        removeIndex(arrayList, index);
        System.out.println("linkedList remove " + index + " th");
        removeIndex(linkedList, index);
        System.out.println();

        System.out.println("arrayList remove Object " + index);
        removeObject(arrayList, index);
        System.out.println("linkedList remove Object " + index);
        removeObject(linkedList, index);
        System.out.println();

        System.out.println("arrayList add");
        add(arrayList);
        System.out.println("linkedList add");
        add(linkedList);
        System.out.println();

        System.out.println("arrayList iterator");
        iterator(arrayList);
        System.out.println("linkedList iterator");
        iterator(linkedList);
        System.out.println();

        System.out.println("arrayList foreach");
        foreach(arrayList);
        System.out.println("linkedList foreach");
        foreach(linkedList);
        System.out.println();

        System.out.println("arrayList forSize");
        forSize(arrayList);
        System.out.println("linkedList forSize");
//        forSize(linkedList);
        System.out.println("wait: ...");
        System.out.println();


    }

    private static void addData(List<Integer> list, int size) {
        long begin = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            list.add(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - begin));
    }

    private static void getIndex(List<Integer> list, int index) {
        long begin = System.currentTimeMillis();
        list.get(index);
        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - begin));
    }

    private static void setIndex(List<Integer> list, int index) {
        long begin = System.currentTimeMillis();
        list.set(index, 1024);
        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - begin));
    }

    private static void addIndex(List<Integer> list, int index) {
        long begin = System.currentTimeMillis();
        list.add(index, 1024);
        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - begin));
    }

    private static void removeIndex(List<Integer> list, int index) {
        long begin = System.currentTimeMillis();
        list.remove(index);
        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - begin));
    }

    private static void removeObject(List<Integer> list, Object obj) {
        long begin = System.currentTimeMillis();
        list.remove(obj);
        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - begin));
    }

    private static void add(List<Integer> list) {
        long begin = System.currentTimeMillis();
        list.add(1024);
        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - begin));
    }

    private static void iterator(List<Integer> list) {
        long begin = System.currentTimeMillis();
        Iterator<Integer> ite = list.iterator();
        while (ite.hasNext()) {
            ite.next();
        }
        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - begin));
    }

    private static void foreach(List<Integer> list) {
        long begin = System.currentTimeMillis();
        for (Integer i : list) {
            //do nothing
        }
        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - begin));
    }

    private static void forSize(List<Integer> list) {
        long begin = System.currentTimeMillis();
        int size = list.size();
        for (int i = 0; i < size; i++) {
            list.get(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - begin));
    }


}		
		]]>
		</programlisting>
	</section>
	<section id="Vector">
		<title>Vector</title>
		<programlisting>
		<![CDATA[
import java.util.Vector;
public class VectorToArray {

  public static void main(String[] args) {

     // Creating a Vector of String elements
     Vector<String> vector = new Vector<String>();

     // Add elements to Vector
     vector.add("Item1");
     vector.add("Item2");
     vector.add("Item3");
     vector.add("Item4");
     vector.add("Item5");
     vector.add("Item6");

    //Converting Vector to String Array
    String[] array = vector.toArray(new String[vector.size()]);

    //Displaying Array Elements
    System.out.println("String Array Elements :");
    for(int i=0; i < array.length ; i++){
       System.out.println(array[i]);
    }
  }
}
		
		]]>
		</programlisting>
	</section>

	<section id="set">
		<title>Set</title>
		<section>
			<title>Set 初始化</title>
			<programlisting>
			<![CDATA[
    private List<Fragment> fragmentList = new ArrayList<>() {{
        add(new ShareFullscreenFragment());
        add(new StoryFullscreenFragment());
        add(new MessageFullscreenFragment());
        add(new MeFullscreenFragment());
    }};
			]]>
			</programlisting>
		</section>
		<section>
			<title>Set 转为 List</title>
			<programlisting>
			<![CDATA[
		// 将Map Key 转化为List      
        List<String> mapKeyList = new ArrayList<String>(map.keySet());    
        System.out.println("mapKeyList:"+mapKeyList);  
          
        // 将Map Key 转化为List      
        List<String> mapValuesList = new ArrayList<String>(map.values());    
        System.out.println("mapValuesList:"+mapValuesList);  			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
Set<Type> set = new Set<>();
Set<Type> set = new HashSet<>();		
			]]>
			</programlisting>
		</section>

		<section id="Set.of()">
			<title>Set.of()</title>
			<programlisting>
			<![CDATA[
Set<Integer> ints = Set.of(1, 2, 3);		
			]]>
			</programlisting>
		</section>
		<section id="Set.toArray">
			<title>Set to Array</title>
			<para>Set.toArray(IntFunction)</para>
			<screen>
		<![CDATA[
	@Test
    public void testCollectionToArray(){
        Set<String> names = Set.of("Fred", "Wilma", "Barney", "Betty");
        String[] copy = new String[names.size()];
        names.toArray(copy);
        System.out.println(Arrays.toString(copy));
        System.out.println(Arrays.toString(names.toArray(String[]::new)));
    }
		]]>
			</screen>

		</section>
	</section>
	<section id="map">
		<title>Map</title>
		<screen>
		<![CDATA[
Map
 ├Hashtable
 ├HashMap
 └WeakHashMap
 
 Map接口
　　请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个 value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。
Hashtable类
　　Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
　　添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。
Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取出一个数，比如2，用相应的key：
　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方 法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相 同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如 果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希 表的操作。
　　如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
　　Hashtable是同步的。
HashMap类
　　HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap 的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。
WeakHashMap类
　　WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。
		]]>
		</screen>
		<section id="Map.of">
			<title>初始化</title>
			<programlisting>
		<![CDATA[
	Map<String, Object> data = new HashMap<String, Object>() {
		{
			put("name", "neo");
		}
	};		
		]]>
			</programlisting>

			<section id="map.static">
				<title>static map</title>
				<programlisting>
			<![CDATA[
	private static final Map<String, String> point;
	static {
		point = new HashMap<String, String>();
		point.put("CN", "China");
		point.put("HK", "Hongkong");
		point.put("TW", "Taiwan");
	};
			]]>
				</programlisting>
				<programlisting>
			<![CDATA[
	public final static Map<String, String> hostMap = new HashMap<String, String>() {
        {
            put("redis", "127.0.0.1");
            put("solr", "127.0.0.1");
        }
	};
		
		
	public final static Map map = new HashMap() {{      
	    put("key1", "value1");      
	    put("key2", "value2");      
	}};  		
			]]>
				</programlisting>
			</section>
			<section>
				<title>Collections 初始化 Map</title>
				<para></para>
				<programlisting>
				<![CDATA[
Map<String, String> emptyMap = Collections.emptyMap();
				
public static Map<String, String> createSingletonMap() {
    return Collections.singletonMap("username1", "password1");
}
				
				]]>
				</programlisting>
			</section>
			<section>
				<title>使用 Collectors.toMap（）初始化 Map</title>
				<para>数组方式</para>
				<programlisting>
				<![CDATA[
Map<String, String> map = Stream.of(new String[][] {
  { "Hello", "World" }, 
  { "Neo", "Chen" }, 
}).collect(Collectors.toMap(data -> data[0], data -> data[1]));
				
				]]>
				</programlisting>
				<para>对象方式</para>
				<programlisting>
				<![CDATA[
 Map<String, Integer> map = Stream.of(new Object[][] { 
     { "Neo", 1 }, 
     { "Netkiller", 2 }, 
 }).collect(Collectors.toMap(data -> (String) data[0], data -> (Integer) data[1]));				
				]]>
				</programlisting>
				<para>使用 Collectors.collectingAndThen（）初始化不可变的Map</para>
				<programlisting>
				<![CDATA[
Map<String, String> map = Stream.of(new String[][] { 
    { "Hello", "World" }, 
    { "John", "Doe" },
}).collect(Collectors.collectingAndThen(
    Collectors.toMap(data -> data[0], data -> data[1]), 
    Collections::<String, String> unmodifiableMap));
				]]>
				</programlisting>
			</section>
			<section>
				<title>使用Map.Entry流初始化 Map</title>
				<para>使用 Entry 接口的SimpleEntry 实现 ：</para>
				<programlisting>
				<![CDATA[
Map<String, Integer> map = Stream.of(
  new AbstractMap.SimpleEntry<>("idea", 1), 
  new AbstractMap.SimpleEntry<>("mobile", 2))
  .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

				]]>
				</programlisting>
				<para>使用SimpleImmutableEntry 实现：</para>
				<programlisting>
				<![CDATA[
Map<String, Integer> map = Stream.of(
  new AbstractMap.SimpleImmutableEntry<>("idea", 1),    
  new AbstractMap.SimpleImmutableEntry<>("mobile", 2))
  .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

				]]>
				</programlisting>
			</section>
			<section>
				<title>Map.of()</title>
				<para></para>
				<programlisting>
				<![CDATA[
Map<String, String> emptyMap = Map.of();
Map<String, String> singletonMap = Map.of("key1", "value");
Map<String, String> map = Map.of("key1","value1", "key2", "value2");				
				]]>
				</programlisting>
			</section>
			<section>
				<title>Map.ofEntries()</title>
				<para></para>
				<programlisting>
				<![CDATA[
Map<String, String> map = Map.ofEntries(
  new AbstractMap.SimpleEntry<String, String>("name", "Neo"),
  new AbstractMap.SimpleEntry<String, String>("city", "Shenzhen"),
  new AbstractMap.SimpleEntry<String, String>("zip", "518000"),
  new AbstractMap.SimpleEntry<String, String>("home", "https://www.netkiller.cn")
);				
				]]>
				</programlisting>
			</section>
		</section>
		<section id="HashMap">
			<title>HashMap</title>
			<section>
				<title>遍历 HashMap</title>

				<programlisting>
			<![CDATA[
Map<String, Integer> session = new HashMap<String, Integer>();

session.put("A",1);
...
...
session.put("Z",26)

for (Map.Entry<String, Integer> entry : session.entrySet()) {
	System.out.println(String.format("%s:%d", entry.getKey(), entry.getValue()));
}

Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
  
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {  
  
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());  
  
} 

			]]>
				</programlisting>
			</section>
			<section>
				<title>遍历map中的键</title>
				<programlisting>
			<![CDATA[
Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
  
//遍历map中的键  
  
for (Integer key : map.keySet()) {  
  
    System.out.println("Key = " + key);  
  
}  			
			]]>
				</programlisting>
			</section>
			<section>
				<title>遍历map中的值 </title>
				<programlisting>
			<![CDATA[
Map<Integer, Integer> map = new HashMap<Integer, Integer>();    
for (Integer value : map.values()) {  
    System.out.println("Value = " + value);  
}  			
			]]>
				</programlisting>
			</section>
			<section>
				<title>通过键取值</title>
				<programlisting>
			<![CDATA[
Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
  
for (Integer key : map.keySet()) {  
  
    Integer value = map.get(key);  
  
    System.out.println("Key = " + key + ", Value = " + value);  
  
}  			
			]]>
				</programlisting>
			</section>
			<section>
				<title>使用 Iterator 遍历 HashMap</title>


				<programlisting>
			<![CDATA[
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
  
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
  
while (entries.hasNext()) {
  
    Map.Entry<Integer, Integer> entry = entries.next();
  
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
  
}  

Map map = new HashMap();  
  
Iterator entries = map.entrySet().iterator();
  
while (entries.hasNext()) {  
  
    Map.Entry entry = (Map.Entry) entries.next();  
  
    Integer key = (Integer)entry.getKey();  
  
    Integer value = (Integer)entry.getValue();  
  
    System.out.println("Key = " + key + ", Value = " + value);  
}  
			]]>
				</programlisting>
			</section>
		</section>

		<section id="LinkedHashMap">
			<title>LinkedHashMap</title>
			<programlisting>
		<![CDATA[
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
public class TestLinkedHashMap {
 
  public static void main(String args[])
  {
   System.out.println("*** LinkedHashMap ***");
   Map<Integer,String> map = new LinkedHashMap<Integer,String>();
   map.put(6, "apple");
   map.put(3, "banana");
   map.put(2,"pear");
   
   for (Iterator it =  map.keySet().iterator();it.hasNext();)
   {
    Object key = it.next();
    System.out.println( key+"="+ map.get(key));
   }
   
   System.out.println("*** HashMap ***");
   Map<Integer,String> map1 = new  HashMap<Integer,String>();
   map1.put(6, "apple");
   map1.put(3, "banana");
   map1.put(2,"pear");
   
   for (Iterator it =  map1.keySet().iterator();it.hasNext();)
   {
    Object key = it.next();
    System.out.println( key+"="+ map1.get(key));
   }
  }
}
		]]>
			</programlisting>
		</section>
		<section id="NavigableMap">
			<title>NavigableMap</title>
			<programlisting>
			<![CDATA[
NavigableMap<Integer, String>map=newTreeMap<>();
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");
map.put(4, "four");

System.out.println("Poll First Entry: "+map.pollFirstEntry());  // 输出 1=one
System.out.println("Poll Last Entry: "+map.pollLastEntry());    // 输出 4=four

map.forEach((key, value) ->System.out.println(key+" :: "+value));			
			]]>
			</programlisting>
			<para>反向遍历</para>
			<programlisting>
			<![CDATA[
NavigableMap 还提供了一些方法，用于反向遍历 Map。你可以通过这些方法，按照降序遍历键值对。
navigableKeySet()：返回一个 NavigableSet，你可以通过它按顺序访问 Map 中的所有键。
descendingKeySet()：返回一个 NavigableSet，你可以通过它反向访问 Map 中的键。
descendingMap()：返回一个新的 NavigableMap，它是原始 Map 的反向视图。
这些方法使得我们能够轻松实现对 Map 键的反向遍历。
			
NavigableMap<Integer, String>map=newTreeMap<>();
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");
map.put(4, "four");
map.put(5, "five");

// 正序遍历
map.keySet().forEach(key->System.out.print(key+" "));  // 输出 1 2 3 4 5
System.out.println();

// 反向遍历
NavigableSet<Integer>descendingKeys=map.descendingKeySet();
descendingKeys.forEach(key->System.out.print(key+" "));  // 输出 5 4 3 2 1			
			]]>
			</programlisting>
			<para>队列式特性：从 Map 中取出元素</para>
			<programlisting>
			<![CDATA[
NavigableMap 提供了一些方法，使得 Map 具有类似队列的操作功能：
pollFirstEntry()：返回并移除 Map 中最小的键值对。
pollLastEntry()：返回并移除 Map 中最大的键值对。
这些方法使得我们可以模拟从 Map 的两端删除元素。
			
NavigableMap<Integer, String>map=newTreeMap<>();
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");
map.put(4, "four");

System.out.println("Poll First Entry: "+map.pollFirstEntry());  // 输出 1=one
System.out.println("Poll Last Entry: "+map.pollLastEntry());    // 输出 4=four

map.forEach((key, value) ->System.out.println(key+" :: "+value));			
			]]>
			</programlisting>
			<para>获取子集视图</para>
			<programlisting>
			<![CDATA[
NavigableMap 还提供了几个方法，用于获取 Map 的子集视图。这些视图是原始 Map 的视图，任何对这些视图的更改都会反映到原始 Map 中。
subMap(fromKey, fromInclusive, toKey, toInclusive)：返回一个子集视图，可以指定是否包含边界键。
headMap(toKey, inclusive)：返回一个子集视图，其中包含小于 toKey 的键，并可以指定是否包含 toKey。
tailMap(fromKey, inclusive)：返回一个子集视图，其中包含大于或等于 fromKey 的键，并可以指定是否包含 fromKey。
这些方法允许你更精细地控制对 Map 中部分元素的访问。			
			
NavigableMap<Integer, String>map=newTreeMap<>();
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");
map.put(4, "four");
map.put(5, "five");

// 获取从 2 到 4 的子集视图（包括边界）
NavigableMap<Integer, String>subMap=map.subMap(2, true, 4, true);
subMap.forEach((key, value) ->System.out.println(key+" :: "+value));			
			]]>
			</programlisting>
		</section>
		
		<section id="Map.loop">
			<title>遍历数据</title>
			<programlisting>
			<![CDATA[
        Map<Integer, String> map = new HashMap<Integer, String>(){{
            put(1, "127.0.0.1");
            put(2, "192.168.0.1");
            put(3, "172.16.0.1");
        }};
        for (Integer key : map.keySet()) {
            System.out.println("key= "+ key + ", value= " + map.get(key));
        }			
			]]>
			</programlisting>
		</section>
		<section id="Map.Iterator">
			<title>迭代器</title>
			<programlisting>
			<![CDATA[
        Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }			
			]]>
			</programlisting>
		</section>
		<section id="map.forEach">
			<title>Map forEach</title>
			<programlisting>
		<![CDATA[
Map<String, Integer> items = new HashMap<>();
items.put("A", 10);
items.put("B", 20);
items.put("C", 30);
items.put("D", 40);
items.put("E", 50);
items.put("F", 60);

items.forEach((k,v)->System.out.println("key : " + k + "; value : " + v));

//output
key : A value : 10
key : B value : 20
key : C value : 30
key : D value : 40
key : E value : 50
key : F value : 60

items.forEach((k,v)->{
    System.out.println("key : " + k + " value : " + v);
});	
		]]>
			</programlisting>
		</section>
		<section id="Map随机取值">
			<title>随机取值</title>
			<programlisting>
			<![CDATA[
        Map<Integer, String> map = new HashMap<Integer, String>(){{
            put(1, "127.0.0.1");
            put(2, "192.168.0.1");
            put(3, "172.16.0.1");
        }};

        Integer[] keys = map.keySet().toArray(new Integer[0]);
        Random random = new Random();
        Integer randomKey = keys[random.nextInt(keys.length)];
        String randomValue = map.get(randomKey);

        System.out.println(randomValue);			
			]]>
			</programlisting>
		</section>
		<section>
			<title>有序 Key 值，HashMap 与 LinkedHashMap 对比</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

@Data
@Slf4j
public class Test {

    public static void main(String[] args) throws InterruptedException {

        Map<String, String> hashMap = new HashMap<String, String>();
        hashMap.put("key0", "value0");
        hashMap.put("key1", "value1");
        hashMap.put("key2", "value2");
        Set<Map.Entry<String, String>> set = hashMap.entrySet();
        for (Map.Entry entry : set) {
            String key = (String) entry.getKey();
            String value = (String) entry.getValue();
            System.out.println("key:" + key + " value:" + value);
        }

        System.out.println("=".repeat(20));
        Map<String, String> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("key0", "value0");
        linkedHashMap.put("key1", "value1");
        linkedHashMap.put("key2", "value2");
        Set<Map.Entry<String, String>> set1 = linkedHashMap.entrySet();
        for (Map.Entry entry : set1) {
            String key = (String) entry.getKey();
            String value = (String) entry.getValue();
            System.out.println("key:" + key + " value:" + value);
        }

    }

}			
			]]>
			</programlisting>
		</section>
		<section>
			<title>调换 map 的 key 与 value 位置</title>
			<programlisting>
			<![CDATA[
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class MapInverter {
    public static void main(String[] args) {
        Map<String, Integer> originalMap = new HashMap<>();
        originalMap.put("A", 1);
        originalMap.put("B", 2);
        originalMap.put("C", 3);

        // 反转键值对（要求 value 唯一）
        Map<Integer, String> invertedMap = originalMap.entrySet().stream()
                .collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));

        System.out.println(invertedMap); // 输出: {1=A, 2=B, 3=C}
    }
}			
			]]>
			</programlisting>
		</section>
	</section>
	<section id="Iterator">
		<title>Iterator</title>
		<para>Iterator接口包含四个方法：hasNext，next，remove，forEachRemaining</para>
		<section>
			<title>List 迭代</title>
			<programlisting>
		<![CDATA[
package cn.netkiller.test;

import java.util.Iterator;
import java.util.List;

public class Test {

    public static void main(String[] args) {
        Test test = new Test();

//        ArrayList<String> arrayList = new ArrayList<String>();

        List<String> list = List.of("Neo", "Tom", "Jerry");

        System.out.printf("%s for %s\n", "=".repeat(10), "=".repeat(10));
        for (String name : list) {
            System.out.println(name);
        }
        System.out.printf("%s forEach %s\n", "=".repeat(10), "=".repeat(10));
        list.forEach(obj -> {
            System.out.println(obj);
        });


        Iterator<String> iterator = list.iterator();
        
        System.out.printf("%s while %s\n", "=".repeat(10), "=".repeat(10));
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        System.out.printf("%s forEachRemaining %s\n", "=".repeat(10), "=".repeat(10));
        iterator.forEachRemaining(System.out::println);

    }
}		
		]]>
			</programlisting>
		</section>
		<section>
			<title>处理剩余结果</title>
			<programlisting>
			<![CDATA[
iterator.forEachRemaining(System.out::println);
			]]>
			</programlisting>
		</section>
		<section>
			<title>Map 迭代</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class Test {

    public static void main(String[] args) {
        System.out.printf("%s Map<Integer, String> %s\n", "=".repeat(10), "=".repeat(10));
        Map<Integer, String> map = new HashMap<Integer, String>();
        for (int i = 0; i < 10; i++) {
            map.put(i, "map" + i);
        }
        Iterator iterMap = map.entrySet().iterator();
        while (iterMap.hasNext()) {
            Map.Entry strMap = (Map.Entry) iterMap.next();
            System.out.println("key: " + strMap.getKey() + ", value: " + strMap.getValue());
        }
    }
}			
			]]>
			</programlisting>
		</section>
		<section>
			<title>Iterator 与 List 的区别</title>
			<para>List 加载后放入内存，可以可以反复使用，Iterator 一旦调用 next() 就会从内存中清除，无法再次引用。
			</para>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.util.Iterator;
import java.util.List;

public class Test {

    public static void main(String[] args) {

        List<String> list = List.of("Neo", "Tom", "Jerry");

        System.out.printf("%s List<String> %s\n", "=".repeat(10), "=".repeat(10));
        list.forEach(System.out::println);

        Iterator<String> iterator = list.iterator();

        System.out.printf("%s next() %s\n", "=".repeat(10), "=".repeat(10));
        String name = iterator.next();
        System.out.println(name);

        System.out.printf("%s forEachRemaining() %s\n", "=".repeat(10), "=".repeat(10));
        iterator.forEachRemaining(System.out::println);

        System.out.printf("%s while hasNext() %s\n", "=".repeat(10), "=".repeat(10));
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

    }
}
			]]>
			</programlisting>
			<para>输出结果</para>
			<screen>
			<![CDATA[
========== List<String> ==========
Neo
Tom
Jerry
========== next() ==========
Neo
========== forEachRemaining() ==========
Tom
Jerry
========== while hasNext() ==========
			]]>
			</screen>
		</section>
		<section>
			<title>remove() 删除操作</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {

    public static void main(String[] args) {

        List<String> list = new ArrayList<>(List.of("Neo", "Tom", "Jerry"));

        System.out.printf("%s List<String> %s\n", "=".repeat(10), "=".repeat(10));
        list.forEach(System.out::println);
        Iterator<String> iterator = list.iterator();

        System.out.printf("%s remove() %s\n", "=".repeat(10), "=".repeat(10));
        while (iterator.hasNext()) {
            String name = iterator.next();

            if (name.equals("Tom")) {
                iterator.remove();
            } else {
                System.out.println(name);
            }

        }

    }
}			
			]]>
			</programlisting>
			<para>UnsupportedOperationException 异常</para>
			<programlisting>
			<![CDATA[
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.base/java.util.ImmutableCollections.uoe(ImmutableCollections.java:142)
	at java.base/java.util.ImmutableCollections$ListItr.remove(ImmutableCollections.java:387)
	at cn.netkiller.test.Test.main(Test.java:36)			
			]]>
			</programlisting>
			<para>List.of 跟 Arrays.asList 不支持 remove() 操作，会抛出
				UnsupportedOperationException 异常。
			</para>
			<programlisting>
			<![CDATA[
List<String> list = List.of("Neo", "Tom", "Jerry");
List<String> list = Arrays.asList("Neo", "Tom", "Jerry");
			]]>
			</programlisting>
		</section>
		<section>
			<title>Iterable 转 List</title>
			<programlisting>
			<![CDATA[
	Iterable<Entity> iterable = repository.findAll();
	List<Entity> list = new ArrayList<>();
	iterable.forEach(single->{list.add(single);});
 
  	List<String> result = new ArrayList<String>();
    iterable.forEach(result::add);
 
    List<String> result = new ArrayList<String>();
    for (String str : iterable) {
        result.add(str);
    } 			
    
    List<String> result = new ArrayList<String>();
    while (iterator.hasNext()) {
        result.add(iterator.next());
    }
    
	List<String> result = StreamSupport.stream(iterable.spliterator(), false).collect(Collectors.toList());
	List<String> result = StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED), false).collect(Collectors.toList());

    List<String> result = new ArrayList<String>();
    iterator.forEachRemaining(result::add);
    
			]]>
			</programlisting>
		</section>

		<section id="ListIterator">
			<title>ListIterator</title>
			<para>ListIterator 可以实现添加/删除和向前/向后访问数据</para>
			<para>Iterator 可以用于 List / Set / Vector / Map 数据结构，ListIterator 只能用于
				List
			</para>
			<programlisting>
		<![CDATA[
package cn.netkiller.test;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

public class Test {

    public static void main(String[] args) {
        Test test = new Test();
        List<String> arrayList = new ArrayList<String>();
        List<String> linkedList = new LinkedList<String>();

        linkedList.add("Neo");
        linkedList.add("Tom");
        linkedList.add("Jerry");
        ListIterator<String> listIterator = linkedList.listIterator();
        String first = listIterator.next();

        System.out.printf("%s List<String> %s\n", "=".repeat(10), "=".repeat(10));
        System.out.println("first:" + first);

        listIterator.remove();

        System.out.printf("%s forEachRemaining %s\n", "=".repeat(10), "=".repeat(10));
        listIterator.add("Netkiller");
        listIterator.forEachRemaining(System.out::println);

        arrayList.add("Netkiller Linux 手札");
        arrayList.add("Netkiller Java 手札");
        arrayList.add("Netkiller Sprint 手札");

        listIterator = arrayList.listIterator();
        System.out.printf("%s next() %s\n", "=".repeat(10), "=".repeat(10));
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }

        listIterator.add("Netkiller MySQL 手札");

        System.out.printf("%s previous() %s\n", "=".repeat(10), "=".repeat(10));
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }
    }
}		
		]]>
			</programlisting>
			<programlisting>
		<![CDATA[
String next = listIterator.next();
if( "Neo".equals(next)) {
    listIterator.set("Netkiller");
}		
		]]>
			</programlisting>
			<programlisting>
		<![CDATA[
List<String> items = new ArrayList<String>();
String nextWithIndex = items.get(listIterator.nextIndex());
String previousWithIndex = items.get(listIterator.previousIndex());		
		]]>
			</programlisting>
		</section>
		<section id="Iterable">
			<title>Iterable</title>
			<para>在 Java 中，Iterable接口是所有可迭代集合（如List、Set等）的父接口，其核心方法iterator()返回一个Iterator对象，用于遍历集合元素。</para>
			<programlisting>
			<![CDATA[
Iterable<String> iterable = Arrays.asList("a", "b", "c");

// for-each循环直接遍历元素
for (String element : iterable) {
    System.out.println(element); // 输出：a、b、c
}
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
Iterable<Integer> numbers = Arrays.asList(1, 2, 3, 4);
Iterator<Integer> iterator = numbers.iterator();

// 循环判断是否有下一个元素
while (iterator.hasNext()) {
    Integer num = iterator.next(); // 获取下一个元素
    System.out.println(num);
    
    // 示例：删除偶数（仅支持可修改的集合，如ArrayList，不可修改集合会抛异常）
    if (num % 2 == 0) {
        iterator.remove(); // 必须在next()之后调用，否则报错
    }
}			
			]]>
			</programlisting>		
			<para>对于支持流式操作的Iterable（如集合类），可通过stream()或parallelStream()转换为流，结合 Lambda 表达式实现函数式遍历：</para>
			<programlisting>
			<![CDATA[
Iterable<String> words = Arrays.asList("apple", "banana", "cherry");

// 转换为流并遍历
words.forEach(word -> System.out.println(word.toUpperCase())); // 输出大写字母

// 更复杂的流操作（过滤、映射等）
((Collection<String>) words).stream() // 注意：需强转为Collection才能调用stream()
    .filter(word -> word.length() > 5)
    .forEach(System.out::println); // 输出：banana、cherry			
			]]>
			</programlisting>
			<para>遍历自定义 Iterable 对象，若你自定义了实现Iterable接口的类，只需重写iterator()方法，即可使用上述所有遍历方式：</para>
			<programlisting>
			<![CDATA[
public class MyIterable implements Iterable<String> {
    private String[] data = {"x", "y", "z"};

    @Override
    public Iterator<String> iterator() {
        return new Iterator<String>() {
            private int index = 0;

            @Override
            public boolean hasNext() {
                return index < data.length;
            }

            @Override
            public String next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                return data[index++];
            }
        };
    }

    // 测试遍历
    public static void main(String[] args) {
        MyIterable myIterable = new MyIterable();
        for (String s : myIterable) {
            System.out.println(s); // 输出：x、y、z
        }
    }
}			
			]]>
			</programlisting>
		</section>
	</section>
	<section id="java.util.Queue">
		<title>Queue</title>
		<programlisting>
		<![CDATA[
	Queue<String> queue = new Queue<String>();
	queue.offer("1");
	queue.offer("2");
	queue.offer("3");
	queue.offer("4");
	System.out.println("当前第一个元素: " + queue.peek());// 取队列第一个元素
	System.out.println("出列第一个元素: " + queue.poll());// 出列第一个元素
	System.out.println("当前第一个元素: " + queue.peek());// 取队列第一个元素		
		]]>
		</programlisting>

		<section>
			<title>阻塞队列</title>
			<para>阻塞队列是一个可以阻塞的先进先出集合，比如某个线程在空队列获取元素时、或者在已存满队列存储元素时，都会被阻塞。</para>
			<para>BlockingQueue 接口常用的实现类如下：</para>
			<literallayout>
			<![CDATA[
ArrayBlockingQueue ：基于数组的有界阻塞队列，必须指定大小。
LinkedBlockingQueue ：基于单链表的无界阻塞队列，不需指定大小。
PriorityBlockingQueue ：基于最小二叉堆的无界、优先级阻塞队列。
DelayQueue：基于延迟、优先级、无界阻塞队列。
SynchronousQueue ：基于 CAS 的阻塞队列。			
			]]>
			</literallayout>

		</section>
		<section id="LinkedBlockingQueue">
			<title>LinkedBlockingQueue</title>
			<programlisting>
			<![CDATA[
        LinkedBlockingQueue<Integer> sequence = new LinkedBlockingQueue<Integer>() {{
            add(10);
            add(50);
            add(100);
            add(1000);
        }};			
			]]>
			</programlisting>
			<programlisting>
				<![CDATA[
	LinkedBlockingQueue<String> voice = new LinkedBlockingQueue<String>();
    voice.add("第一句，你是哪里的人");
    voice.add("第二句，你住在哪里啊");
    voice.add("第三句，你叫什么名字");
    voice.add("第四句，你从事什么职业");
    voice.add("第五句，问完了");				
				]]>
			</programlisting>
		</section>
		<section>
			<title>Deque 双端队列</title>
			<programlisting>
			<![CDATA[
public class Main  {
    public static void main(String[] args) {

        Deque deque = new LinkedList<String>();
        deque.push("one");
        deque.push("two");
        deque.push("three");
        while (deque.peek() != null) 
             System.out.println(deque.pop());
    }
}			
			]]>
			</programlisting>
			<section>
				<title>LinkedList</title>
				<programlisting>
			<![CDATA[
public class QueueTest {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList();
        queue.offer("元素A");
        queue.offer("元素B");
        queue.offer("元素C");
        queue.offer("元素D");
        queue.offer("元素E");
        while (queue.size() > 0) {
            String element = queue.poll();
            System.out.println(element);
        }
    }
}
			]]>
				</programlisting>

				<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.util.LinkedList;
import java.util.Queue;

public class QueueTest {
    public static void main(String[] args) {

        Queue<String> queue = new LinkedList<String>();
        //添加元素
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        queue.offer("d");
        queue.offer("e");
        
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("poll="+queue.poll()); //返回第一个元素，并在队列中删除
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("element="+queue.element()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("peek="+queue.peek()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
        //add()和remove()方法在失败的时候会抛出异常(不推荐)
    }
}
			]]>
				</programlisting>
				<programlisting>
			<![CDATA[
public class Main {
    public static void main(String[] args) {
        LinkedList queue = new LinkedList();
        queue.add(1);
        queue.add(2);
        queue.add(3);

        //FIFO 先进先出 通过removeFirst()验证一下
        while (!queue.isEmpty())
            System.out.println(queue.removeFirst());
    }
}
			
public class Main {
    public static void main(String[] args) {
        LinkedList queue = new LinkedList();
        queue.add(1);
        queue.add(2);
        queue.add(3);

        // 当作栈区使用 removeLast() 先进后出
        while (!queue.isEmpty())
            System.out.println(queue.removeLast());
    }
}

输出结果
3
2
1			
			]]>
				</programlisting>
			</section>
		</section>
		<section>
			<title>数据转换</title>
			<programlisting>
			<![CDATA[
		String str = "酒店坐落于青岛崂山区金融CBD，背靠历史悠久的“海上名山第一”崂山，迎黄海湾峡绵延悠长。风景秀美壮观，于酒店眺望闻名于世的青岛石老人景观，清风朗日浪花缱绻让人沉醉。国际娱乐标杆美高梅集团精心打造334间奢华畅阔客房，成为同城豪华旅居全新乐选之地。酒店拥有五间风格迥异餐厅、酒吧吧及糕点屋，资深大厨呈现五洲美食，惊喜不绝。";
        String[] arr = str.split("。");
        LinkedBlockingQueue<String> voice = new LinkedBlockingQueue<String>(Arrays.asList(arr));			
			]]>
			</programlisting>
		</section>
		<section>
			<title>PriorityBlockingQueue</title>

		</section>
	</section>
	<section id="Stack">
		<title>Stack</title>
		<programlisting>
		<![CDATA[
        Stack<Integer> sequence = new Stack<Integer>();
        sequence.push(10);
        sequence.push(50);
        sequence.push(100);
        sequence.push(1000);		
		]]>
		</programlisting>
	</section>
	<section id="Optional">
		<title>Optional</title>
		<screen>
	<![CDATA[
Optional.of("javastack").orElseThrow(); // javastack
 // 1

	]]>
		</screen>
		<section id="Optional.of()">
			<title>of() 为非null的值创建一个Optional。</title>
			<para>of方法通过工厂方法创建Optional类。需要注意的是，创建对象时传入的参数不能为null。如果传入参数为null，则抛出NullPointerException
				。
			</para>
			<programlisting>
		<![CDATA[
		Optional<String> name = Optional.of("netkiller");
		if (name.isPresent()) {
			// 在Optional实例内调用get()返回已存在的值
			System.out.println(name.get());// 输出 netkiller
		}		
		]]>
			</programlisting>
			<para>传入参数为null，抛出NullPointerException.</para>
			<programlisting>
		<![CDATA[
Optional<String> someNull = Optional.of(null);		
		]]>
			</programlisting>
		</section>
		<section id="Optional.ofNullable()">
			<title>ofNullable() 为指定的值创建一个Optional，如果指定的值为null，则返回一个空的Optional。
			</title>
			<programlisting>
		<![CDATA[
		Optional<String> name = Optional.ofNullable("netkiller");
		if (name.isPresent()) {
			// 在Optional实例内调用get()返回已存在的值
			System.out.println(name.get());// 输出 netkiller
		}

		Optional<String> empty = Optional.ofNullable(null);
		if (empty.isPresent()) {
			System.out.println(empty.get());
		}
		]]>
			</programlisting>
		</section>
		<section id="Optional.isPresent()">
			<title>isPresent 如果值存在返回true，否则返回false。ifEmpty() null 返回 true 否则返回
				false
			</title>
			<programlisting>
		<![CDATA[
	//isPresent方法用来检查Optional实例中是否包含值
	if (name.isPresent()) {
		System.out.println(name.get());
	}
		]]>
			</programlisting>

			<para>ifEmpty() 与 ifPresent() 刚好相反</para>
		</section>
		<section id="Optional.ifEmpty()">
			<title>ifPresent() 如果Optional实例有值执行 lambda 表达式</title>
			<para>如果Optional实例有值，调用ifPresent()可以接受接口段或lambda表达式。类似下面的代码：</para>
			<programlisting>
		<![CDATA[
	Optional<String> name = Optional.ofNullable("netkiller");

	name.ifPresent((value) -> {
		System.out.println("hello " + value);
	});

	name.ifPresent((value) -> {
		System.out.println(value.length());
	});		
		]]>
			</programlisting>
		</section>
		<section id="Optional.get()">
			<title>get() 返回值</title>
			<para>如果Optional有值则将其返回，否则抛出NoSuchElementException。</para>
			<programlisting>
		<![CDATA[
		Optional<String> name = Optional.ofNullable("netkiller");
		System.out.println(name.get());
		
		Optional<String> empty = Optional.ofNullable(null);
		try {
			System.out.println(empty.get());
		} catch (NoSuchElementException e) {
			System.out.println(e.getMessage());
		}		
		]]>
			</programlisting>
			<para>输出内容</para>
			<screen>
		<![CDATA[
netkiller
No value present		
		]]>
			</screen>
		</section>
		<section id="Optional.orElse()">
			<title>orElse 如果有值则将其返回，否则返回指定的其它值。</title>
			<para>如果Optional实例有值则将其返回，否则返回orElse方法传入的参数。示例如下：</para>
			<programlisting>
		<![CDATA[
package cn.netkiller.test;

import java.util.Optional;

public class OptionalTest {

	public OptionalTest() {
		// TODO Auto-generated constructor stub
	}


	public static void main(String[] args) {

		Optional<String> name = Optional.ofNullable("netkiller");

		Optional<String> empty = Optional.ofNullable(null);

		System.out.println(name.orElse("There is some value!"));
		System.out.println(empty.orElse("There is no value present!"));

	}

}
		]]>
			</programlisting>
			<para>输出</para>
			<screen>
		<![CDATA[
netkiller
There is no value present!		
		]]>
			</screen>
			<para>指定默认值</para>
			<programlisting>
		<![CDATA[
	User user = new User();
	user.setId(1);
	user.setUsername("Neo");
	
	Optional<User> user = Optional.ofNullable(user).orElse(new User(0, "Unknown"));

	System.out.println("Username is: " + user.getUsername());
		
		]]>
			</programlisting>
		</section>
		<section id="Optional.orElseGet()">
			<title>orElseGet与orElse方法类似，区别在于得到的默认值从 Supplier 返回。</title>
			<para>orElseGet方法可以接受Supplier接口的实现用来生成默认值。示例如下：</para>
			<programlisting>
		<![CDATA[
package cn.netkiller.test;

import java.util.Optional;

public class OptionalTest {

	public OptionalTest() {
		// TODO Auto-generated constructor stub
	}


	public static void main(String[] args) {

		Optional<String> name = Optional.ofNullable("netkiller");

		Optional<String> empty = Optional.ofNullable(null);

		System.out.println(name.orElseGet(() -> "There is some value!"));
		System.out.println(empty.orElseGet(() -> "There is no value present!"));

	}

}		
		]]>
			</programlisting>
			<para></para>
			<programlisting>
		<![CDATA[
Optional<User> user = Optional.ofNullable(user).orElseGet(() -> new User(0, "Unknown"));		
		]]>
			</programlisting>
		</section>
		<section id="Optional.orElseThrow()">
			<title>orElseThrow 如果有值则将其返回，否则抛出supplier接口创建的异常</title>
			<programlisting>
		<![CDATA[
Optional<User> user = Optional
        .ofNullable(user)
        .orElseThrow(() -> new EntityNotFoundException("id=" + id + " 的用户没有找到"));
		]]>
			</programlisting>
			<para>使用场景举例</para>
			<programlisting>
		<![CDATA[
@RequestMapping("/user/{id}")
public User getUser(@PathVariable Integer id) {
    Optional<User> user = userService.getUserById(id);
    return user.orElseThrow(() -> new EntityNotFoundException("id=" + id + " 的用户不存在"));
}

@ExceptionHandler(EntityNotFoundException.class)
public ResponseEntity<String> handleException(EntityNotFoundException ex) {
    return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
}		
		]]>
			</programlisting>
			<programlisting>
		<![CDATA[
package cn.netkiller.test;

import java.util.Optional;

public class OptionalTest {

	public OptionalTest() {
		// TODO Auto-generated constructor stub
	}

	public static class ValueAbsentException extends Throwable {

		private static final long serialVersionUID = -1758502952187236809L;

		public ValueAbsentException() {
			super();
		}

		public ValueAbsentException(String msg) {
			super(msg);
		}

		@Override
		public String getMessage() {
			return "No value present in the Optional instance";
		}
	}

	public static void main(String[] args) {

		Optional<String> empty = Optional.ofNullable(null);

		try {
			// orElseThrow会抛出lambda表达式或方法生成的异常
			empty.orElseThrow(ValueAbsentException::new);
		} catch (Throwable ex) {
			// 输出 No value present in the Optional instance
			System.out.println(ex.getMessage());
		}

	}

}
		]]>
			</programlisting>
		</section>
		<section id="Optional.map()">
			<title>map() 方法用来对Optional实例的值执行一系列操作</title>
			<para>map方法用来对Optional实例的值执行一系列操作。通过一组实现了Function接口的lambda表达式传入操作。map方法示例如下：
			</para>
			<programlisting>
		<![CDATA[
	Optional<String> name = Optional.ofNullable("netkiller");
	Optional<String> upperName = name.map((value) -> value.toUpperCase());
	System.out.println(upperName.orElse("No value found"));		
		]]>
			</programlisting>
			<para></para>
			<programlisting>
		<![CDATA[
		Optional<String> username = Optional.ofNullable("netKiller-Neo")
				.map((value) -> value.toLowerCase())
				.map((value) -> value.replace("n", "N"))
				.map(value -> value.replace('-', '_'));

		System.out.println("Username is: " + username.orElse("Unknown"));		
		]]>
			</programlisting>
		</section>
		<section id="Optional.flatMap()">
			<title>flatMap()</title>
			<para>与 map() 区别在于flatMap中的mapper返回值必须是Optional</para>
			<programlisting>
		<![CDATA[
		Optional<String> username = Optional.ofNullable("netKiller-Neo").flatMap((value) -> Optional.of(value.toUpperCase()));

		System.out.println("Username is: " + username.orElse("No value found"));		
		]]>
			</programlisting>
		</section>
		<section id="Optional.filter()">
			<title>filter() 通过传入限定条件过滤Optional值</title>
			<programlisting>
		<![CDATA[
package cn.netkiller.test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class OptionalTest {

	public OptionalTest() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {

		for (String item : List.of("Neo", "Jerry", "Netkiller")) {
			Optional<String> username = Optional.of(item).filter((value) -> value.length() > 6);
			System.out.println("name is: " + username.orElse("The name is less than 6 characters"));
		}
	}

}
		
		]]>
			</programlisting>
			<para>使用多个 filter 组合过滤数据</para>
			<programlisting>
		<![CDATA[
		List.of("Neo", "Jerry", "Netkiller", "Tom", "Anni", "Lisa", "Leo").forEach(item -> {
			Optional.of(item).filter((value) -> value.length() > 2).filter((value) -> value.contains("o")).ifPresent((n) -> {
				System.out.println(n);
			});
		});		
		]]>
			</programlisting>

		</section>
		<section id="Optional.stream()">
			<title>stream()</title>
			<programlisting>
		<![CDATA[
Optional.of("javastack").stream().count();		
		]]>
			</programlisting>
		</section>
		<section id="Optional.or()">
			<title>or()</title>
			<programlisting>
		<![CDATA[
	String string = (String) Optional.ofNullable(null).or(() -> Optional.of("netkiller")).get();
	System.out.println(string);		
		]]>
			</programlisting>
		</section>
		<section id="Optional.example">
			<title>example</title>
			<section>
				<title>Optional 与 Map</title>

				<programlisting>
				<![CDATA[
		Optional<Map<String, Object>> name = Optional.of(new HashMap<String, Object>() {
			{
				put("id", 1);
				put("name", "Neo");
				put("age", 30);
			}
		});

		System.out.println(name.toString());
		name.map((m) -> m.put("count", 1));
		System.out.println(name.get());
		name.map((m) -> m.put("nickname", "netkiller"));
		name.map((m) -> m.remove("id"));
		System.out.println(name.get());
		Optional<Map<String, Object>> tmp = name.filter((m) -> ((Integer) m.get("age")) == 30);
		System.out.println("filter: " + tmp.get());		
				]]>
				</programlisting>
			</section>
			<section>
				<title>判断 Object 是否为 null</title>
				<programlisting>
				<![CDATA[
package cn.netkiller.utils;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.io.Serial;
import java.io.Serializable;
import java.util.Optional;

@Data
@Slf4j
public class ResponseJson implements Serializable {
    @Serial
    private static final long serialVersionUID = 1L;
    private final boolean status; // 状态代码
    private final Code code; // 业务响应码
    private final Object data; // 返回业务参数
    private String reason = ""; // 返回信息描述

    public ResponseJson(boolean status, Code code, String reason, Object data) {
        this.status = status;
        this.code = code;
        this.reason = reason;
        this.data = data;
    }

    public ResponseJson(Object data) {
        Optional<Object> optional = Optional.ofNullable(data);
//        log.info(String.valueOf(optional.isEmpty()));
//        log.info(String.valueOf(optional.isPresent()));
//        log.info(String.valueOf(optional.get()));
        if (optional.isEmpty()) {
            this.status = false;
            this.code = Code.FAIL;
            this.reason = "失败";
            this.data = null;
        } else {
            this.status = true;
            this.code = Code.SUCCESS;
            this.reason = "成功";
            this.data = data;
        }
    }

    public enum Code {
        SUCCESS, // 业务处理成功
        COMPLIANCE, NONCOMPLIANT, ILLEGAL, FAIL // 业务处理失败

    }
}				
				]]>
				</programlisting>
			</section>
			<section>
				<title>默认值</title>
				<para>当 dish 为空，将返回 new Dish()</para>
				<screen>
				<![CDATA[
Optional<Dish> dish1 = Optional.of(dish).orElse(new Dish());
				]]>
				</screen>
			</section>
			<section>
				<title>返回数据</title>
				<programlisting>
				<![CDATA[
    @GetMapping("get/{id}")
    public AigcResponse query(@PathVariable("id") int id) {
        Optional<Account> optional = accountService.findById(id);
        return optional.map(AigcResponse::new).orElseGet(() -> new AigcResponse(new Account()));
    }				
				]]>
				</programlisting>
			</section>
		</section>
	</section>
</chapter>