JAVA基础22----List

1.ArrayList去除集合中字符串的重复值
package com.guada.list;

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

public class Demo1 {

	/**
	 * ArrayList去除集合中字符串的重复值（字符的内容相同）
	 */
	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add("a");
		list.add("a");
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("b");
		ArrayList list1 = new ArrayList();
		list1 = getSingle(list);
		System.out.println(list1);                  
	}
	/*
	 * 创建新集合将重复元素去掉
	 * 1.明确返回值类型，返回ArrayList
	 * 2.明确参数列表ArrayList
	 * 
	 * 分析：
	 * 1.创建新集合
	 * 2.根据传入的集合获取迭代器
	 * 3.遍历传入的集合
	 * 4.判断新集合中是否包含新集合中的元素，不包含就添加
	 * */
	public static  ArrayList getSingle(ArrayList list) {
		ArrayList list1 = new ArrayList();                             //创建一个新集合
		Iterator it = list.iterator();                                        //获取传入集合的迭代器
		while(it.hasNext()) {
			Object obj = it.next();                                          //记录元素
			if(!list1.contains(obj)) {
				list1.add(obj);
			}
		}
		return list1;
	}
}

2.package com.guada.list;

import java.util.LinkedList;

public class Demo3 {

	/**
	 * LinkedList的一些常用方法
	 * public void addFirst(E e)及addLast(E e)
	 * public E  getFirst()及getLast()
	 * public E removeFirst()及public E removeLast()
	 * public E get(int index )
	 */
	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		list.addFirst("d");
		list.addFirst("c");
		list.addFirst("b");
		list.addFirst("a");
		list.addLast("e");
		
		System.out.println(list);
		System.out.println(list.getFirst());
		System.out.println(list.getLast());
		list.removeFirst();
		list.removeLast();
		System.out.println(list);
		System.out.println(list.get(1));
	}

}

3.package com.guada.list;

import java.util.LinkedList;

// 使用linkedList模拟数据结构的栈结构
public class Stack {
	private LinkedList list = new LinkedList();
	
	//进栈
	public  void in (Object obj) {
		list.addLast(obj);
	}
	
	//出栈
	
	public Object out () {
		return list.removeLast();
	}
	
	//判空
	
	public boolean isEmpty() {
		return list.isEmpty();
	}
	
}

package com.guada.list;

public class Demo4 {

	/**
	 * LinkedList模拟进栈操作
	 */
	public static void main(String[] args) {
		Stack s = new Stack();
		s.in("a");
		s.in("b");
		s.in("c");
		s.in("d");
		
		while(!s.isEmpty()) {
			System.out.println(s.out());
		}
		
		System.out.println(s);
	}

}

4.package com.guada.list;

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

public class Demo5_Generic {

	/**
	 * 泛型概述：
	 * 	泛型好处
	 * 		提高安全性（将运行期的错误转换到编译期）
	 * 		省去强转的麻烦
	 * 泛型基本使用
	 * 	<>中放的必须是引用数据类型
	 * 泛型使用注意事项
	 * 	前后的泛型必须一致，或者后面的泛型可以省略不写（1.7的新特性菱形泛型）
	 * 
	 */
	public static void main(String[] args) {
//		demo1();
		//int [] arr = new byte[5];               //数组要保证前后的数据类型一致
//		ArrayList<Object> list = new ArrayList<Person>(); //集合的泛型要保证前后的数据类型一致
//		ArrayList<Object> list = new ArrayList<>();             //菱形泛型
		//泛型不要定义成Object，没有意义
	}

	public static void demo1() {
		LinkedList<Person> list = new LinkedList<Person>();               //泛型的作用指定引用数据类型
		list.add(new Person("张三",23));
		list.add(new Person("李四",24));
		
		Iterator<Person> it = list.iterator();
		while(it.hasNext()) {
			Person  p = it.next();
			System.out.println(p.getName()+"-----"+p.getAge());
		}
	}

}

5.方法泛型最好与类的泛型一致
如果不一致，需要在方法上声明该泛型
静态方法必须声明自己的泛型

```java

```java
6.package com.guada.list;

public class Demo6_Generic {

	/**
	 * 泛型接口
	 * 	把泛型定义在接口上
	 * 定义的格式：
	 * 	public interface 接口名<泛型类型>
	 */
	public static void main(String[] args) {

	}

		
}

interface Inter<T>{
	public  void show(T t);
}
//class Demo implements Inter<String> {   //推荐使用
//
//	@Override
//	public void show(String t) {
//		System.out.println(t);
//	}
//	
//}

class Demo<T> implements Inter<T> {

	@Override
	public void show(T t) {
		System.out.println(t); 
	}
	
}

7.package com.guada.list;

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

public class Demo7_Generic {

	/**
	 * 泛型通配符<?>
	 * 		任意类型，如果没有明确，那么就是object以及任意的JAVA类
	 * ？ extends E
	 * 		向下限定，E及其子类
	 * ？super E
	 * 		向上限定，E及其父类
	 */
	public static void main(String[] args) {
		List<?> list1 = new ArrayList<String>();                        //当右边的泛型是不确定的时，左边可以指定为？
	}

}

8.package com.guada.list;

import java.util.ArrayList;

public class Demo8_Foreach {

	/**
	 * Foreach
	 * 	简化数组和collection集合的遍历
	 * 格式：
	 * 	for（元素数据类型 变量：数组或者Collection集合） {
	 * 			使用变量即可，该变量就是元素
	 *    }
	 */
	public static void main(String[] args) {
		int [] arr = {11,22,33,44,55};
		for (int i : arr) {
			System.out.println(i);
		}
		
		ArrayList<String> list = new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		for (String string : list) {
			System.out.println(string);
		}
	}

}

9.package com.guada.list;

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

public class Demo9_Delect {

	/**
	 * 三种迭代删除的方法比较
	 * 	1.for循环删除
	 * 	2.Iterator迭代器遍历删除
	 * 	3.fore迭代
	 */
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("d");
		
		//for循环进行的遍历
//		for (int i = 0; i < list.size(); i++) {
//			if("b".equals(list.get(i))) {
//				list.remove(i--);
//			}
//		}
//		System.out.println(list);
		
		//Iterator迭代器遍历
//		Iterator<String> it = list.iterator();
//		while(it.hasNext()) {
//			if("b".equals(it.next())) {
//				it.remove();
//			}
//		}
//		System.out.println(list);
		//fore遍历
		for (String string : list) {
			if("b".equals(string)) {
				list.remove(string);                      //ConcurrentModificationException,因为fore的底层依赖的是Iterator，不能在遍历的过程中对list进行删除修改的操作，会引起并发修改异常，所以fore遍历的过程中不能进行删除的操作
			
			}
		}
		System.out.println(list);
}
	
}

10.静态导入：
	静态导入是导入类中的静态方法
格式:
		import static 包名/类名.方法名；
		能看懂即可，在实际的开发中不使用

11.
	 可变参数：
	 			定义方法的时候不知道该定义多少个参数
	 格式：
	 			修饰符  返回值类型  方法名（数据类型   变量名）{}
	 这里的变量其实是一个数组
	 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

12.package com.guada.list;

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

public class Demo10_ChangeableArgs {
//	static <T> List<T>
//	asList(T... a) 
//	返回由指定数组支持的固定大小的列表
	public static void main(String[] args) {
//		数组转变成集合
//		不能增加或者减少元素
//		将数组转换成集合，数组必须是引用数据类型
//		基本数据类型的数组转换成集合，会将整个数组当成一个对象进行存储
		String [] arr = {"a","b","c"};
		List<String> list = Arrays.asList(arr);
		System.out.println(list);
		list.add("d");                                 //UnsupportedOperationException,不支持更改异常
		System.out.println(list);
	}

}

13.package com.guada.list;

import java.util.ArrayList;

public class Demo11_ArrayListArrayList {

	/**
	 * 集合嵌套
	 */
	public static void main(String[] args) {
		ArrayList<ArrayList<Person>> list = new ArrayList<ArrayList<Person>>();
		ArrayList<Person> first = new ArrayList<Person>();
		first.add(new Person("张三", 23));
		first.add(new Person("李四", 24));
		first.add(new Person("王五", 25));
		
		ArrayList<Person> second = new ArrayList<Person>();
		first.add(new Person("小明", 26));
		first.add(new Person("小芳", 27));
		first.add(new Person("小红", 28));
		
		list.add(first);
		list.add(second);
		
		System.out.println(list);
	}

}