对于List、Set、Map的学习

泛型

概念

一种不确定的数据类型,用以将数据类当作参数传递和返回
达到一种方法可接受多种数据类型的目的

定义

<T,X,....>

使用

在方法上使用

public class Test {
    public static void main(Stirng [] args){
        Integer i= test(1);
        String str=test("123");
        Test t=new Test();
        Test test=test(t);
    }
    
    //返回于传入类型相同的返回值
    public static <X> X test(X str){
        return str;
    }
    
    //方法可接收任意类型的参数
    public static <X,Y> void test01(X x,Y y1,Y y2){
        
    }
}

在类中使用

/**
*	类上定义泛型,必须在类名定义之后,继承与接口实现实现之前,紧随类名
*/
public class Person<K,Y,Z> extends Object{
    private K k;
    private Y y;
    private Z z;
    private String str;
    
    public Person(){
        super();
    }
    
    public Person(K k,Y y, Z z, String str){
        super();
        this.k=k;
        this.y=y;
        this.z=z;
        this.str=str;
    }
    
    public K getK(){
        return K;
    }
    
    public void setK(K k){
        this.k=k;
    }
    
    public Y getY(){
        return y;
    }
    
    public void setY(Y y){
        this.y=y;
    }
    
    public Z getZ(){
        return z;
    }
    
    public void setZ(Z z){
        this.z=z;
    }
    
    public String getStr() {
		return str;
	}

	public void setStr(String str) {
		this.str = str;
	}

	@Override
	public String toString() {
		return "Person [k=" + k + ", y=" + y + ", z=" + z + ", str=" + str + "]";
	}
}


public class Test {
	public static void main(String[] args) {
        //创建对象时要指明泛型所表示的数据类型(不可用八种数据类型要用其包装类)
		Person<Integer, String, Boolean> person = new Person<Integer, String, Boolean>();
		Person<String, Integer, Integer> person2 = new Person<String, Integer, Integer>();
	}
}

在接口上使用

public class java{
	public static void main(String[] args) {
		//通过匿名内部类实现接口
        MyInterfaceTest<String> test = new MyInterfaceTest<String>();
		new MyInterface<Integer>() {
			@Override
			public void test01(Integer k) {
			}
			@Override
			public Integer test02(Integer k) {
				return null;
			}
		};
	}
}
interface MyInterface<K>{
	void test01(K k);
	K test02(K k);
}
class MyInterfaceTest<K> implements MyInterface<K>{

	@Override
	public void test01(K k) {
	}
	@Override
	public K test02(K k) {
		return null;
	}
}

泛型的优点

1,省略了强转代码,并且避免了强制转换产生的数据丢失等情况
2,可以把运行时的问题提前到编译时期

集合

集合框架图(来自菜鸟教程)

概念

存储一组数据类型相同的数据(只能是引用数据类型),长度可变

体系

Collection:接口

特点:无序(存入顺序与取出顺序不同),无下标
  方法:
	增:
		boolean add(E e) 增加一个数据
        boolean addAll(Collection <? extends E> c):将子集合中的数据添加到集合中
            
    删:
		boolean remove(Object o);删除一个数据
        boolean removeAll(Collection <?> c); 将子集合中所有数据从集合中删除
        void clear(); 清空集合
            
	查:
		int size(); 获取集合中元素的个数
        boolean contains(Object o); 判断指定元素是否存在集合中
        boolean containsAll(Collection<?> c); 判断子集合中所有数据是否都在集合中
        Iterator<E> iterator(); 迭代器
     
	其他:
		boolean isEmpty();判断集合中是否不存在元素
        Object[] toArray(); 将集合中转换为数组

子接口:List

特点:有序,有下标
	子类特有的方法
	增:
		一次插入一个数据,1参为插入位置 2参为插入数据
        void add(int index, E element);
				
		一次插入一组数据, 1参插入开始位置 2参插入数据
        void addAll(int index, Collection<? extends > c);

	删:
		按照下标删除指定位置的数据
		E remove(int index);
        
	改:
		修改指定位置的数据,1参下标,2参修改后的数据
		E set(int index);
		
	查:
		获取指定位置的数据,参数下标
		E get(int index);

	子类
		ArrayList  jdk1.2出现,线程不安全
		数据结构:数组
		特点:查询快,增删慢
                
		Vector    	jdk1.0出现,线程安全
		数据结构:数组
                  
		LinkedList jdk1.2出现,线程不安全
		数据结构:链表
		特点:增删快,查询慢               

子接口Set

特点:无序,无下标,不可重复
	子类特有方法:无
	子类:
			HashSet  jdk1.2出现,线程不安全
			数据结构:链表+红黑树(基于哈希表)
            
			LinkedHashSet jdk1.4,线程不安全
			数据结构:链表+红黑树(基于哈希表)+链表
			特点:有序
                     
			TreeSet
			数据结构:链表+红黑树
			方案一:
				数据自身拥有比较性
				步骤1:让存储的数据所属的类实现Comparable
				步骤2:重写 compareTo 方法
						
			方法二:
				提供比较器
				创建 TreeSet 对象时,传入比较器的对象(可通过匿名内部类来实现)
                   

关于List和Set的子集的toString()方法

	List和Set子集并没有重写 toString() 方法但是在生成子集对象后通过子集对象调用 toSatring() 方法后发现 toString() 方法被重写，是因为List和Set继承了 AbstractList 和AbstractSet ，这两者继承了 AbstractCollection 类，该类对 toString() 进行了重写
Map与其相识

操作集合的工具类:Collections

用以操作集合的工具类
常用方法:
Collections.sort(list);//排序 只有List集合可使用
Collections.reverse(list);//翻转字符串 只有List集合可使用
Integer max=Collections.max(list);//寻找最大值
Integer max=Collections.max(list);//寻找最小值

Map接口(字典)

概念

存储一组数据类型相同的数据,长度可变
数据的要求:键值对应

体系

Map(接口)
	HashMap(类)
		特点:链表+红黑树(哈希表),线程不安全,1.2
	HashTable(类)
		特点:链表+红黑树(哈希表),线程安全,1.0
		Properties(类)
	TreeMap(类)
		特点:链表+红黑树
		注意:
			TreeMap存储数据,键(key)要么拥有比较性,要么在创建TreeMap时传入比较器

Map的方法

特点: 存储的数据格式为键值对应
方法:
	增
		V put(K key, V value); //增加一个数据
		注意:如果字典中key不存在,则是添加,如果key存在,那么将修改key对应的value
		void putAll(Map<? extends K, ? extends V> m); //将一个Map集合添加至该集合中
	删
        V remove(Object key);//删除集合中键为 key 的数据
        void clear(); //清空该Map集合
	改
		V put(K key, V value); //通过键来更改值,若键不存在则添加该键值对
	查
        int size(); //查询集合中的元素的个数
        boolean isEmpty(); //判断集合是否为空
        boolean containsKey(Object key); //判断集合中是否存在键为key的元素
        boolean containsValue(Object value); //判断集合中是否存在值为value的元素
        V get(Object key);//通过键获取值
        Set<K> keySet(); //获取Map集合中所有键,并返回一个set集合
        Collection<V> values(); //获取Map集合中所有的值,并将其存入一个集合对象中
        Set<Map.Entry<K, V>> entrySet(); //将一个Map集合转为Entry集合,其中一个Entry表示Map中的一对键值对
	Entry中的方法:
		K	getKey();//获取Entry的键
		V	getValue();//获取Entry的值