list和set、map的简单总结，以及具体实现代码和练习

List：有序的集合，可以重复
set：无序的集合，不可以重复
map：key-value（web基础）

List和set Collection：
Collection
add（E）用于添加元素
remove（E）：用于删除元素

size（）：返回元素的个数
isEmpty（）：个数是否为0

add和remove方法的使用

package cn.tedu.collection;

import java.util.ArrayList;
import java.util.Collection;

//测试Collection接口的常用方法
public class Demo {
	/**
	 * jdk5.0之后出现的
	 * Collection coll = new ArrayList();
	 * @param args
	 * jdk1.7之后
	 * Collection coll = new ArrayList<>();
	 */
	public static void main(String[] args) {
		Collection coll = new ArrayList<>();
		//必须只能在尖括号里面放入引用类型
		Collection coll1 = new ArrayList<>();
		System.out.println(coll.isEmpty());//true
		coll1.add(1);//里面写进本数据类型是因为其进行了自动封箱
		coll.add("abcde");
		coll.add("hello");
		boolean b =coll.isEmpty();//null size=0
		System.out.println(b);//false
		
		System.out.println(coll.size());//得到集合里面的元素的个数
		//看集合里面是否包含“hello”
		System.out.println(coll.contains("hello"));//true
		coll.remove("hello");
		System.out.println(coll.size());//1
		coll.clear();
		System.out.println(coll.isEmpty());//true
		
		
	}

}

将list按顺序输出到服务台的三种方式：

for（E e：collection）{}：增强for循环输出
iterator：使用迭代器
forEach（）：使用lambda表达式输出

package cn.tedu.collection;

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

import org.omg.Messaging.SyncScopeHelper;

public class Demo2 {
	public static void main(String[] args) {
		Collection coll = new ArrayList<>();
		Collection coll1 = new ArrayList<>();
		coll1.add(1);//里面写进本数据类型是因为其进行了自动封箱
		coll.add("abcde");
		coll.add("hello");
		coll.add("123456");
		
		//第一种方式：增强for循环
		for(String str:coll){
			System.out.println(str);
		}
		System.out.println("++++++++++++++++++++++++++");
		
		//第二种方式：迭代器
		Iterator it = coll.iterator();
		while(it.hasNext()){
			String str = it.next();//字符串类型的
			System.out.println(str);
		}
		System.out.println("------------------------------");
		
		//第三种方式：lambda
		coll.forEach(a->System.out.println(a));
		//for (T t : this)
        //    action.accept(t);

		
	}

}

List：泛型接口
ArrayList：数组

package cn.tedu.collection;

import java.util.ArrayList;
import java.util.Collection;

public class Demo3 {
	public static void main(String[] args) {
		Collection c1= new ArrayList<>();
		c1.add("C");
		c1.add("C++");
		c1.add("java");
		Collection c2= new ArrayList<>();
		c2.add("jsp");
		c2.add("php");
		c2.add("java");
		boolean b= c1.contains(c2);
		System.out.println(b);//false
		boolean b2=c1.addAll(c2);
		//c1.forEach(str->System.out.println(str));
		//c1.removeAll(c2);
		c1.forEach(str->System.out.println(str));//C C++ java jsp php java 
		System.out.println("-----------------------");
	}

}

在list里面进行索引删除：
add方法add(index ,E e)
remove(index);
set(index, E e)完成修改功能，set里面没有，因为set无序，没办法使用修改
get(index)
for(int i = 0;i

package cn.tedu.collection;

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

public class Demo4 {
	public static void main(String[] args) {
		List list=new ArrayList<>();
		list.add("hello");
		list.add(0,"abc");
		list.forEach(str->System.out.print(str+" "));
		list.set(1, "11111");
		list.forEach(str->System.out.print(str+" "));
		list.remove(0);
		list.forEach(str->System.out.println(str+" "));
		System.out.println("----------------------");
		for(int i =0;i

和集合相关的操作：
addAll();
removeAll();
containsAll();

数组转集合：Arrays.asList();集合转换成数组toArray（）：toArray（T[] t）

package cn.tedu.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Demo5 {
	//集合转换成数组
	public static void test1(){
		List list=new ArrayList<>();
		list.add("hello");
		list.add(0,"abc");
		List list2 =new ArrayList<>();
		list2.add(1);list2.add(18);
		list2.add(2);list2.add(12);
		Object[] obj= list2.toArray();
		int sum=0;
		for(Object object:obj){
			sum+=(Integer)object;
		}
		Integer[] li = list2.toArray(
				new Integer[list2.size()]);
		for(Integer i:li){
			sum+=i;
		}
		//排序操作
		Arrays.sort(li);
		System.out.println(Arrays.toString(li));
		String[] strs = new String[list.size()];
		Arrays.sort(list.toArray(strs));
		System.out.println(Arrays.toString(strs));
	}
	
	//重写比较算法，然后按照这个重写的方法进行排序等操作
	static Comparator com = new Comparator(){
		public int compare(String o1, String o2) {
			return o1.length()-o2.length();
		}
	};
	//数组转换成集合 asList()
	//给集合排序 Collections.sort(list);,都是从小到大的顺序进行的排序
	public static void test2(){
		String[] str ={"hello","abce","bdes","ao"};
		//List list =new ArrayList<>();
		List list = Arrays.asList(str);//把数组变成集合
		Collections.sort(list);//其底层也是使用的Arrays.sort()方法
		System.out.println(list);
		//Collections.sort(list, com);//按照字符串的长度进行的排序
		Collections.sort(list,(o1,o2)->o1.length()-o2.length());
		System.out.println(list);

	}
	public static void main(String[] args) {
		test2();
	}

}

排序：

Comparable：嵌入到排序的类里面
Comparator：在外部排序，改变默认的排序规则
Arrays.sort(数组)：里面是数组排序
Collections.sort(List)：是对list进行的排序操作

TestSort.java:

package cn.tedu.collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
 * 按照学生成绩排序
1.定义student类：
两个变量：name，score
方法
2.定义集合，3个student对象 添加到集合
3.使用sort方法排序，排序时指定排序规则

4.输出排序后的集合
 * @author cll
 *
 */
public class TestSort {
	public static void main(String[] args) {
		List stu=new ArrayList<>();
		stu.add(new Student("张三",60));
		stu.add(new Student("lisa",86));
		stu.add(new Student("jack",88));
		Collections.sort(stu,(stu1,stu2)->
		stu1.getScore()-stu2.getScore());
		System.out.println(stu);
		System.out.println("----------------------------");
		//第二种方法
		//需要Student2实现接口Comparable
		List stu2=new ArrayList<>();
		stu2.add(new Student2("张三",60));
		stu2.add(new Student2("lisa",86));
		stu2.add(new Student2("jack",88));
		Collections.sort(stu2);
		System.out.println(stu2);
	}

}

Student类需要创建 两个构造方法以及一个toString方法以及两个变量的get、set方法

String name;
    int score;
    public Student(){
    }
    public Student(String name,int score){
        super();
        this.name=name;
        this.score=score;
    }

泛型：

java泛型设计原则：保证在编译的时候不出现错误，运行时就不会出现类强制转换异常：ClassCastException

泛型类和普通方法的区别

在void之前有一个表示泛型方法
T[]可以让各种类型的数组进下面方法的使用

//输出任意数据类型的数组元素
    public static  void showData(T[] a){
        for(T t:a){
            System.out.println(t);
        }
    }
    public static  void test3(){
        //不能写int[]，因为泛型使用的是引用类型的数组
        Integer[] n ={1,2,3,4,5};
        showData(n);
    }

子类明确泛型类型参数变量不是泛型类时：

子类不明确泛型的类型参数变量，里面的泛型类型会一直是T，是泛型类
以接口为例：泛型接口

package cn.tedu.T;
interface DemoInter{
	void show(T t);
}
class DemoImpl implements DemoInter{

	@Override
	public void show(String t) {
		// TODO Auto-generated method stub
		System.out.println(t);
	}
	
}
class DemoImpl1 implements DemoInter{

	@Override
	public void show(T t) {
		// TODO Auto-generated method stub
		System.out.println(t);
	}
	
}
public class Demo {

	public static void main(String[] args) {
		DemoInter d1 =new DemoImpl<>();
		DemoInter d2 =new DemoImpl<>();
		d1.show("qsdcvbnm,");
		d2.show("123455678890");
	}

}

设置通配符的上限：？ extends T
设置通配符的下限：？ super T

package cn.tedu.T;

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

public class Demo3 {
	//设置通配符的上限
		public static void test(List list){
			for(Number obj:list){
				System.out.println(obj);
			}
		}
	
	//设置通配符的下限
		public static void test2(List list1){
			for(Object obj:list1){
				System.out.println(obj);
			}
		}
	public static void main(String[] args) {
		//测试通配符的上限
		//需要设置的类型要小于上面设置的Number类型
		List str = new ArrayList<>();
		str.add(1);
		str.add(2);
		str.add(3);
		test(str);
		System.out.println("------------------------------");
		//测试通配符的下限
		//这个Object比上面的test2里面的Number大，所以不会报错
		List