集合之Collection家族的 List接口+LinkedList+Vector+Stack及Set接口+HashSet+LinkedHashSet+TreeSet

忘是亡心i 2024-04-11 09:57 54阅读 0赞

## 集合之Collection家族的 List接口+LinkedList+Vector+Stack及Set接口+HashSet+LinkedHashSet+TreeSet ##

### 一、LinkedList ###

#### 1.LinkedList的使用 ####

##### 注意：因为LinkedList和ArrayList都实现了List接口(标准)，所以使用上几乎没有区别 #####

import java.util.Arrays;
    import java.util.Collections;
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.ListIterator;
    
    public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		//创建LinkedList对象
    		LinkedList<String> list = new LinkedList<>();
    		
    		//添加元素
    		list.add("夏侯惇");
    		list.add("赵云");
    		list.add("妲己");
    		list.add("瑶妹");
    		list.add("鲁班");
    		list.add("鲁班");
    		
    		//设置指定下标上的元素
    		list.set(2, "貂蝉");
    		
    		//获取指定下标上的元素
    		String str = list.get(3);
    		System.out.println("获取指定下标上的元素：" + str);
    		
    		int size = list.size();
    		System.out.println("获取元素个数：" + size);
    		
    		//插入元素
    		list.add(4,"后裔");
    		
    		
    		LinkedList<String> newList1 = new LinkedList<>();
    		//利用集合工具类做批量添加
    		Collections.addAll(newList1, "aaa","bbb","ccc");
    		//将newList1中所有的元素添加到list末尾
    		list.addAll(newList1);
    		
    		LinkedList<String> newList2 = new LinkedList<>();
    		//利用集合工具类做批量添加
    		Collections.addAll(newList2, "xxx","yyy","zzz");
    		//将newList2中所有的元素添加到list指定下标的位置
    		list.addAll(5,newList2);
    		
    		//清空集合中所有的元素
    		//list.clear();
    		
    		System.out.println("判断集合中是否包含指定元素：" + list.contains("后裔"));
    		System.out.println("判断集合中是否包含子集合：" + list.containsAll(newList2));
    		
    		System.out.println("获取集合中元素第一次出现的下标：" + list.indexOf("鲁班"));
    		System.out.println("获取集合中元素最后一次出现的下标：" + list.lastIndexOf("鲁班"));
    		
    		System.out.println("判断集合中是否不包含元素：" + list.isEmpty());
    		
    		//根据下标删除元素
    		list.remove(5);
    		//根据元素删除元素
    		list.remove("鲁班");
    		//去除交集(删除list中包含了newList1中所有的元素)
    		list.removeAll(newList1);
    		//保留交集(保留list中包含了newList2中所有的元素)
    		list.retainAll(newList2);
    		
    		//替换指定下标上的元素
    		list.set(1, "后裔");
    		
    		//将集合转换为数组
    		Object[] array = list.toArray();
    		System.out.println(array);
    		
    		//将集合转换为数组
    		String[] ss = new String[list.size()];
    		list.toArray(ss);
    		System.out.println(Arrays.toString(ss));
    		
    		System.out.println("----------------------------");
    		
    		
    		//遍历方式1 -- for循环
    		for (int i = 0; i < list.size(); i++) {
        
    			System.out.println(list.get(i));
    		}
    		
    System.out.println("---------------------");
    		
    		//遍历方式2 -- foreach
    		for (String element : list) {
        
    			System.out.println(element);
    		}
    		
    		System.out.println("---------------------");
    		
    		//遍历方式3 -- Iterator
    		Iterator<String> iterator = list.iterator();
    		while(iterator.hasNext()){
        //判断是否有可迭代的元素
    			String next = iterator.next();//返回下一个元素
    			System.out.println(next);
    		}
    		
    		System.out.println("---------------------");
    		
    		//遍历方式4 -- ListIterator
    		ListIterator<String> listIterator = list.listIterator();
    		while(listIterator.hasNext()){
        //判断是否有可迭代的元素
    			String next = listIterator.next();//返回下一个元素
    			System.out.println(next);
    		}
    		
    	}	
    }

#### 2.LinkedList独有的方法 ####

##### LinkedList底层的数据结构：双向链表 #####

import java.util.Arrays;
    import java.util.Iterator;
    import java.util.LinkedList;
    
    public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		
    		LinkedList<String> list = new LinkedList<>();
    		
    		list.add("上官婉儿1");
    		list.add("上官婉儿2");
    		list.add("上官婉儿3");
    		list.add("上官婉儿4");
    		list.add("上官婉儿5");
    		list.add("abc");
    		
    		//将元素添加到双向链表的头部
    		list.addFirst("女娲");
    		//将元素添加到双向链表的尾部
    		list.addLast("凯哥");
    		
    		//删除双向链表的头部元素
    		list.removeFirst();
    		//删除双向链表的尾部元素
    		list.removeLast();
    		
    		//以相反的顺序返回此deque中的元素的迭代器。
    		Iterator<String> descendingIterator = list.descendingIterator();
    		while (descendingIterator.hasNext()) {
        
    			String next = descendingIterator.next();
    			System.out.println(next);	
    		}
    		
    		//获取双向链表中第一个元素
    		String element = list.element();
    		System.out.println("获取双向链表中第一个元素：" + element);
    		
    		//获取双向链表中第一个元素
    		String first = list.getFirst();
    		System.out.println("获取双向链表中第一个元素：" + first);
    		
    		//将元素添加到双向链表的尾部
    		list.offer("苏烈");
    		
    		//将元素添加到双向链表的头部
    		list.offerFirst("aaa");
    		
    		//将元素添加到双向链表的尾部
    		list.offerLast("bbb");
    		
    		//将元素添加到双向链表的头部元素
    		list.push("abc");
    		
    		//获取双向链表头部元素
    		String peek = list.peek();
    		System.out.println("获取双向链表头部元素：" + peek);
    		
    		//获取双向链表头部元素
    		String peekFirst = list.peekFirst();
    		System.out.println("获取双向链表头部元素：" + peekFirst);
    		
    		//获取双向链表尾部元素
    		String peekLast = list.peekLast();
    		System.out.println("获取双向链表尾部元素：" + peekLast);
    		
    		//删除双向链表的头部元素
    		String poll = list.poll();
    		System.out.println("删除双向链表的头部元素：" + poll);
    		
    		//删除双向链表的头部元素
    		String pollFirst = list.pollFirst();
    		System.out.println("删除双向链表的头部元素：" + pollFirst);
    		
    		//删除双向链表的尾部元素
    		String pollLast = list.pollLast();
    		System.out.println("删除双向链表的尾部元素：" + pollLast);
    		
    		//删除双向链表的头部元素
    		String pop = list.pop();
    		System.out.println("删除双向链表的头部元素：" + pop);
    		
    		//删除出现的第一个元素
    		//list.removeFirstOccurrence("abc");
    		
    		//删除出现的最后一个元素
    		list.removeLastOccurrence("abc");
    		
    		System.out.println(Arrays.toString(list.toArray()));
    	}
    }

#### 3.LinkedList – 队列模式 ####

##### 含义：先进先出 #####

import java.util.LinkedList;
    
    public class Test03 {
        
    
    	public static void main(String[] args) {
        
    		
    		LinkedList<String> list = new LinkedList<>();
    		
    		list.add("兰陵王1");
    		list.add("兰陵王2");
    		list.add("兰陵王3");
    		list.add("兰陵王4");
    		list.add("兰陵王5");
    		list.add("兰陵王6");
    		
    		System.out.println("获取元素个数：" + list.size());//6
    		
    		while (!list.isEmpty()) {
        
    			String removeFirst = list.removeFirst();
    			System.out.println(removeFirst);	
    		}
    		
    		System.out.println("获取元素个数：" + list.size());//0
    	}
    }

#### 4.LinkedList – 栈模式 ####

##### 含义：先进后出、后进先出 #####

import java.util.LinkedList;
    
    public class Test04 {
        
    
    	public static void main(String[] args) {
        
    		
    		LinkedList<String> list = new LinkedList<>();
    		
    		//将元素压入栈顶
    		list.push("不知火舞1");
    		list.push("不知火舞2");
    		list.push("不知火舞3");
    		list.push("不知火舞4");
    		list.push("不知火舞5");
    		
    		System.out.println("获取元素个数：" + list.size());//5
    		
    		while (!list.isEmpty()) {
        
    			//删除栈顶元素，并返回
    			String pop = list.pop();
    			System.out.println(pop);
    		}
    		System.out.println("获取元素个数：" + list.size());//0
    	}
    }

### 二、Vector ###

#### 1.Vector的使用 ####

import java.util.Arrays;
    import java.util.Collections;
    import java.util.Iterator;
    import java.util.ListIterator;
    import java.util.Vector;
    
    public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		//创建Vector对象
    		Vector<String> list = new Vector<>();
    		
    		//添加元素
    		list.add("张飞");
    		list.add("关羽");
    		list.add("刘备");
    		list.add("赵云");
    		list.add("马超");
    		list.add("黄忠");
    		list.add("黄忠");
    		
    		//设置指定下标上的元素
    		list.set(3, "曹操");
    		
    		//获取指定下标上的元素
    		String str = list.get(3);
    		System.out.println("获取指定下标上的元素：" + str);
    		
    		//获取元素个数
    		int size = list.size();
    		System.out.println("获取元素个数：" + size);//7
    		
    		//插入元素
    		list.add(4,"韩信");
    		
    		Vector<String> newList1 = new Vector<>();
    		//利用集合工具类做批量添加
    		Collections.addAll(newList1, "aaa","bbb","ccc");
    		//将newList1中所有的元素添加到list末尾
    		list.addAll(newList1);
    		
    		Vector<String> newList2 = new Vector<>();
    		//利用集合工具类做批量添加
    		Collections.addAll(newList2, "xxx","yyy","zzz");
    		//将newList2中所有的元素添加到list指定下标的位置
    		list.addAll(newList2);
    		
    		//清空集合中所有的元素
    		//list.clear();
    		
    		System.out.println("判断集合中是否包含指定元素：" + list.contains("关羽"));
    		System.out.println("判断集合中是否包含子集合：" + list.containsAll(newList1));
    		
    		System.out.println("获取集合中元素第一次出现的下标：" + list.indexOf("黄忠"));
    		System.out.println("获取集合中元素最后一次出现的下标：" + list.lastIndexOf("黄忠"));
    		
    		//(注意：不包含元素返回true，包含元素返回false)
    		System.out.println("判断集合中是否不包含元素：" + list.isEmpty());
    		
    		//根据下标删除元素
    		list.remove(3);
    		
    		//根据元素删除元素
    		list.remove("曹操");
    		
    		//去除交集(删除list中包含了newList1中所有的元素)
    		list.removeAll(newList1);
    		
    		//保留交集(b敖柳list中包含了newList2中所有的元素)
    		list.retainAll(newList2);
    		
    		//替换指定下标上的元素
    		list.set(1,"夏侯惇");
    		
    		//将集合转换为数组
    		Object[] array = list.toArray();
    		System.out.println(Arrays.toString(array));
    		
    		//将集合转换为数组
    		String[] ss = new String[list.size()];
    		list.toArray(ss);
    		System.out.println(Arrays.toString(ss));
    		
    		System.out.println("---------------------");
    		
    		//遍历方式1 -- for循环
    		for (int i = 0; i < list.size(); i++) {
        
    			System.out.println(list.get(i));
    		}
    		
    		System.out.println("-----------------------");
    		
    		//遍历方式2 -- foreach
    		for (String element : list) {
        
    			System.out.println(element);
    		}
    		
    		System.out.println("-------------------------");
    		
    		//遍历方式3 -- Iterator
    		Iterator<String> iterator = list.iterator();
    		while (iterator.hasNext()) {
        
    			//判断是否有可迭代的元素
    			String next =  iterator.next();
    			//返回下一个元素
    			System.out.println(next);
    		}
    		
    		System.out.println("--------------------------");
    		
    		//遍历方式4 -- ListIterator
    		ListIterator<String> listIterator = list.listIterator();
    		while (listIterator.hasNext()) {
        
    			//判断是否有可迭代的元素
    			String next = listIterator.next();
    			//返回下一个元素
    			System.out.println(next);
    			
    		}
    	}
    }

#### 2.Vector原始的方法 ####

##### 1.理解： #####

> Vector是JDK1.0开始就存在集合类（元老级别的集合类），集合框架的概念是从JDK1.2开始，Java的设计者为了将Vector保留下来，又让Vector多实现了一个接口(List)

##### 2.底层的数据结构：一维数组 #####

##### 3.ArrayList vs Vector #####

###### 1.相同点：数据结构是一维数组 ######

###### 2.不同点： ######

> ArrayList线程不安全的
> 
> Vector线程安全的

import java.util.Enumeration;
    import java.util.Vector;
    public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		
    		Vector<String> v = new Vector<>();
    		
    		//添加元素
    		v.addElement("武媚娘1");
    		v.addElement("武媚娘2");
    		v.addElement("武媚娘3");
    		v.addElement("武媚娘4");
    		v.addElement("武媚娘5");
    		v.addElement("武媚娘6");
    		
    		//根据下标删除
    		v.removeElementAt(0);
    		//根据元素删除
    		v.removeElement("武媚娘4");
    		
    		//遍历
    		Enumeration<String> elements = v.elements();
    		while (elements.hasMoreElements()) {
        
    			String nextElement =  elements.nextElement();
    			System.out.println(nextElement);
    		}
    	}
    }

### 三、Stack ###

#### 1.Stack独有的方法 ####

#### 2.特点：栈的数据结构 – 先进后出 ####

#### 3.继承关系：class Stack extends Vector ####

import java.util.Stack;
    
    public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		Stack<String> stack = new Stack<>();
    		
    		//将元素压入栈顶
    		stack.push("大桥1");
    		stack.push("大桥2");
    		stack.push("大桥3");
    		stack.push("大桥4");
    		stack.push("大桥5");
    		stack.push("大桥6");
    		
    		//查询元素距离栈顶的位置(从1开始)
    		int search = stack.search("大桥6");
    		System.out.println("查询元素距离栈顶的位置：" + search);//1
    		
    		//查看栈顶元素
    		String peek = stack.peek();
    		System.out.println("查看栈顶元素：" + peek);//大桥6
    		
    		while (!stack.empty()) {
        
    			String pop = stack.pop();
    			System.out.println(pop);
    		}
    	}
    }

### 四、Set接口 -------HashSet ###

#### 1.HashSet的使用 ####

import java.util.Arrays;
    import java.util.Collections;
    import java.util.HashSet;
    import java.util.Iterator;
    
    public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		//创建HashSet对象
    		HashSet<String> set = new HashSet<>();
    		
    		//添加元素
    		set.add("曹操");
    		set.add("戏志才");
    		set.add("郭嘉");
    		set.add("于禁");
    		set.add("典韦");
    		set.add("夏侯惇");
    		set.add("于禁");
    		
    		//获取元素个数/
    		int size = set.size();
    		System.out.println("获取元素个数：" + size);//7
    		
    		HashSet<String> newSet1 = new HashSet<>();
    		//利用集合工具类做批量添加
    		Collections.addAll(newSet1, "aaa","bbb","ccc");
    		//将newset1中所有的元素添加到set末尾
    		set.addAll(newSet1);
    		
    		//清空集合中所有的元素
           //set.clear();
    		
    		System.out.println("判断集合中是否包含指定元素：" + set.contains("曹操"));//true
    		System.out.println("判断集合中是否包含子集合：" + set.containsAll(newSet1));//true
    		
    		//(注意：不包含元素返回true，包含元素返
    		System.out.println("判断集合中是否不包含元素：" + set.isEmpty());//false 返回false)
    		
    		set.remove("典韦");//根据元素删除元素
    		set.removeAll(newSet1);//去除交集(删除set中包含了newSet1中所有的元素)
    		
    		HashSet<String> newSet2 = new HashSet<>();
    		Collections.addAll(newSet2, "郭嘉","夏侯惇","戏志才");
    		set.retainAll(newSet2);//保留交集(b敖柳set中包含了newset2中所有的元素)
    		
    		//将集合转换为数组
    		Object[] array = set.toArray();
    		System.out.println(Arrays.toString(array));
    		
    		//将集合转换为数组
    		String[] ss = new String[set.size()];
    		set.toArray(ss);
    		System.out.println(Arrays.toString(ss));
    		
    		System.out.println("---------------------");
    		
    		//遍历方式1 -- foreach
    		for (String element : set) {
        
    			System.out.println(element);
    		}
    		
    		System.out.println("---------------------");
    		
    		//遍历方式2 -- Iterator
    		Iterator<String> iterator = set.iterator();
    		while(iterator.hasNext()){
        //判断是否有可迭代的元素
    			String next = iterator.next();//返回下一个元素
    			System.out.println(next);
    		}
    		
    	}
    }

#### 2.理解HashSet为什么无序且不可重复 ####

#### 3.无序：存入顺序和取出顺序不一致（无序不代表随机） ####

#### 4.存入元素的逻辑： ####

##### 1.获取元素的hash值 #####

##### 2.通过hash值计算出在一维数组中的下标 #####

##### 3.判断该下标上是否有元素 #####

###### 1. 没有元素 – 直接将元素存入 ######

###### 2 .有元素 — 判断两个元素是否相同（hash || == && equals） ######

> 不相同 – JDK1.7头插法、JDK1.8尾插法 – （单向链表）
> 
> 相同 — 则不存入（去重的效果）

#### 5.取出元素的逻辑：遍历数组 ####

import java.util.HashSet;
    
    public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		
    		HashSet<String> set = new HashSet<>();
    		
    		set.add("曹操");
    		set.add("戏志才");
    		set.add("郭嘉");
    		set.add("于禁");
    		set.add("典韦");
    		set.add("Aa");//hash值 -- 2112
    		set.add("BB");//hash值 -- 2112
    		
    		for (String element : set) {
        
    			System.out.println(element);
    		}
    	}
    }

### 五、LinkedHashSet ###

#### 1.LinkedHashSet的使用 ####

import java.util.Arrays;
    import java.util.Collections;
    import java.util.LinkedHashSet;
    import java.util.Iterator;
    
    public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		//创建LinkedHashSet对象
    		LinkedHashSet<String> set = new LinkedHashSet<>();
    		
    		//添加元素
    		set.add("曹操");
    		set.add("戏志才");
    		set.add("郭嘉");
    		set.add("于禁");
    		set.add("典韦");
    		set.add("夏侯惇");
    		set.add("于禁");
    		
    		//获取元素个数/
    		int size = set.size();
    		System.out.println("获取元素个数：" + size);//7
    		
    		LinkedHashSet<String> newSet1 = new LinkedHashSet<>();
    		//利用集合工具类做批量添加
    		Collections.addAll(newSet1, "aaa","bbb","ccc");
    		//将newset1中所有的元素添加到set末尾
    		set.addAll(newSet1);
    		
    		//清空集合中所有的元素
           //set.clear();
    		
    		System.out.println("判断集合中是否包含指定元素：" + set.contains("曹操"));//true
    		System.out.println("判断集合中是否包含子集合：" + set.containsAll(newSet1));//true
    		
    		//(注意：不包含元素返回true，包含元素返
    		System.out.println("判断集合中是否不包含元素：" + set.isEmpty());//false 返回false)
    		
    		set.remove("典韦");//根据元素删除元素
    		set.removeAll(newSet1);//去除交集(删除set中包含了newSet1中所有的元素)
    		
    		LinkedHashSet<String> newSet2 = new LinkedHashSet<>();
    		Collections.addAll(newSet2, "郭嘉","夏侯惇","戏志才");
    		set.retainAll(newSet2);//保留交集(b敖柳set中包含了newset2中所有的元素)
    		
    		//将集合转换为数组
    		Object[] array = set.toArray();
    		System.out.println(Arrays.toString(array));
    		
    		//将集合转换为数组
    		String[] ss = new String[set.size()];
    		set.toArray(ss);
    		System.out.println(Arrays.toString(ss));
    		
    		System.out.println("---------------------");
    		
    		//遍历方式1 -- foreach
    		for (String element : set) {
        
    			System.out.println(element);
    		}
    		
    		System.out.println("---------------------");
    		
    		//遍历方式2 -- Iterator
    		Iterator<String> iterator = set.iterator();
    		while(iterator.hasNext()){
        //判断是否有可迭代的元素
    			String next = iterator.next();//返回下一个元素
    			System.out.println(next);
    		}
    		
    	}
    }

#### 2.理解LinkedHashSet为什么无序且不可重复 ####

import java.util.LinkedHashSet;
    
    public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		
    		LinkedHashSet<String> set = new LinkedHashSet<>();
    		
    		set.add("曹操");
    		set.add("戏志才");
    		set.add("郭嘉");
    		set.add("于禁");
    		set.add("典韦");
    
    		
    		for (String element : set) {
        
    			System.out.println(element);
    		}
    	}
    }

### 六 、TreeSet ###

#### 1.TreeSet的使用 ####

import java.util.Arrays;
    import java.util.Collections;
    import java.util.Iterator;
    import java.util.TreeSet;
    
    public class Test01 {
        
    
    	
    	public static void main(String[] args) {
        
    		
    		//创建TreeSet对象
    		TreeSet<String> set = new TreeSet<>();
    		
    		//添加元素
    		set.add("曹操");
    		set.add("戏志才");
    		set.add("郭嘉");
    		set.add("于禁");
    		set.add("典韦");
    		set.add("夏侯惇");
    		set.add("于禁");
    		
    		//获取元素个数
    		int size = set.size();
    		System.out.println("获取元素个数：" + size);//7
    		
    		TreeSet<String> newSet1 = new TreeSet<>();
    		//利用集合工具类做批量添加
    		Collections.addAll(newSet1, "aaa","bbb","ccc");
    		//将newset1中所有的元素添加到set末尾
    		set.addAll(newSet1);
    		
    		//清空集合中所有的元素
            //set.clear();
    		
    		System.out.println("判断集合中是否包含指定元素：" + set.contains("典韦"));//true
    		System.out.println("判断集合中是否包含子集合：" + set.containsAll(newSet1));//true
    		
    		//(注意：不包含元素返回true，包含元素返回false)
    		System.out.println("判断集合中是否不包含元素：" + set.isEmpty());//false (注意：不包含元素返回true，包含元素返回false)
    		
    		//根据元素删除元素
    		set.remove("于禁");
    		//去除交集(删除set中包含了newSet1中所有的元素)
    		set.removeAll(newSet1);
    		
    		TreeSet<String> newSet2 = new TreeSet<>();
    		Collections.addAll(newSet2, "曹操","戏志才","郭嘉");
    		//保留交集(b敖柳set中包含了newset2中所有的元素)
    		set.retainAll(newSet2);
    		
    		//将集合转换为数组
    		Object[] array = set.toArray();
    		System.out.println(Arrays.toString(array));
    		
    		//将集合转换为数组
    		String[] ss = new String[set.size()];
    		set.toArray(ss);
    		System.out.println(Arrays.toString(ss));
    		
    		System.out.println("---------------------");
    		
    		//遍历方式1 -- foreach
    		for (String element : set) {
        
    			System.out.println(element);
    		}
    		
    		System.out.println("---------------------");
    		
    		//遍历方式2 -- Iterator
    		Iterator<String> iterator = set.iterator();
    		while(iterator.hasNext()){
        //判断是否有可迭代的元素
    			String next = iterator.next();//返回下一个元素
    			System.out.println(next);
    		}
    		
    	}
    }

#### 2.理解TreeSet的自然排序 ####

##### 自然排序：根据不同的类型选择不同的排序方式 #####

import java.util.Arrays;
    import java.util.TreeSet;
    
    public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		
    		//TreeSet存储Integer类的排序方式：数字升序
    		TreeSet<Integer> set1 = new TreeSet<>();
    		
    		set1.add(4);
    		set1.add(2);
    		set1.add(1);
    		set1.add(5);
    		set1.add(3);
    		set1.add(3);
    		set1.add(1);
    		System.out.println(Arrays.toString(set1.toArray()));
    		
    		//TreeSet存储String类的排序方式：字典排序
    		TreeSet<String> set2 = new TreeSet<>();
    		set2.add("a");
    		set2.add("c");
    		set2.add("bd");
    		set2.add("c");
    		set2.add("b");
    		set2.add("d");
    		set2.add("bc");
    		System.out.println(Arrays.toString(set2.toArray()));
    	}
    }