Java培训总结笔记（二）

一.集合

（一）Collection接口
Collection是最基本的集合接口，用API文档的话说，是层次结构中的根接口。Collection表示一组对象，这些对象也称为Collection的元素。Collection最常用的子接口有List接口和Set接口。
1.List接口
List接口是有序的Collection接口（也称为序列），允许存在重复元素，优势在于可以对列表中每个元素的插入位置进行精确地控制。其中，最常用的两个类是ArrayList和LinkedList。
(1)ArrayList类
特点：底层使用数组实现，查找性能高。
具体操作：
1>元素添加

    //主要使用list.add()方法
    private static void m1(){
        ArrayList list =new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("123");
        System.out.println(list);
        }

2>元素删除

    //主要使用list.remove()方法
    private static void m1(){
        ArrayList list =new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");      
        //根据索引删除
        list.remove(0);//从0开始排序；删除第一个元素
        System.out.println(list);
        //根据内容删除
        list.remove("b");
        System.out.println(list);   
    }

3>元素修改

    //主要使用list.set()方法
    private static void m2(){
        ArrayList list =new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("123");
        System.out.println(list);
        list.set(2, "r");//指定第几号位置的元素改为其他什么元素
        System.out.println(list);
    }

4>元素查找

    //主要使用list.get()方法
    private static void m3() {
        ArrayList list =new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("123");
        System.out.println(list);
        String v =(String)list.get(0);//获得第几号位置的元素，同时强制类型转换为String类型并赋值给一个新声明的String类对象v
        System.out.println(v);  
    }

(2)LinkedList类
特点：底层使用链表实现，便于增添和删除操作。
具体操作：
主要的元素的增删改查和ArrayList一样，这里主要介绍LinkedList的pop方法，即弹栈，从此列表所表示的堆栈处弹出第一个元素，代码如下

    //用list.pop()方法弹栈
    private static void m1(){
        LinkedList list = new LinkedList();
        list.push("a");
        list.push("b");
        list.push("c");
        list.pop();
        System.out.println(list);//根据栈的插入顺序可知，运行结果为[b,a]
    }

2.Set接口
Set接口是无序的Collection接口（也称为集），不允许存在重复元素，检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。最常用的类为HashSet。
HashSet类
特点：由哈希表（实际上是一个HashMap实例）支持，为增删改查等基本操作提供稳定性能。
具体操作：
1>添加元素和判断元素是否在一个集合中

    //主要用set.add()方法和set.contains()方法
    private static void m1(){
        HashSet set =new HashSet();
        //添加元素
        set.add("zhangsan");
        set.add("lisi");
        set.add("wangwu");
        System.out.println(set);
        //判断一个元素是否存在集合中
        boolean b=set.contains("lis");//返回值是一个布尔类型，所以需要声明一个布尔类型变量并赋值
        System.out.println(b);
    }

2>元素的遍历（按内部存储机制的顺序）

    //用Iterator迭代器遍历
    private static void m2() {
        HashSet set =new HashSet();
        set.add("zhangsan");
        set.add("lisi");
        set.add("wangwu");
        //调用Iterator迭代器方法
        Iterator ite=set.iterator();
        while(ite.hasNext()){
            System.out.println(ite.next());
        }
    }

（二）Map接口
以键-值对的形式存储（可称为映射），将键映射到值的对象。一个映射不能包含重复的键（key值不可重复，但value值可重复）；每个键最多只能映射到一个值。最常用的类为HashMap。
HashMap类
特点：基于哈希表的Map接口的实现，为基本操作提供稳定性能。
具体操作：
1>元素的添加、查找和删除

    //添加用map.put()方法，查找用map.get()方法，删除用map.remove()方法
    private static void m1() {
        HashMap map=new HashMap();
        //元素的添加，参数为“键”和“值”
        map.put("a","苹果");
        map.put("b","葡萄");
        map.put("c","西瓜");
        //元素的查找（获取）
        String v=(String)map.get("b");
        System.out.println(v);
        //元素的删除
        map.remove("a");
        System.out.println(map);
    }

2>元素的遍历及修改

    //涉及多种类型转换
    private static void m2() {
        HashMap map=new HashMap();
        map.put("a","苹果");
        map.put("b","葡萄");
        map.put("c","西瓜");
        Set set = map.entrySet();//转化为set存储，返回此映射所包含的映射关系的Set视图
        Iterator ite=set.iterator();//对这个set进行迭代，因为HashMap没有Iterator方法，而set有
        while(ite.hasNext()){
            Map.Entry entry =(Entry) ite.next();//再强制转换为entry对象，进而方便获取键和值，entry有getKey()和getValue()方法
            String key=(String) entry.getKey();//将获取的键强制转换为String类型
            if("b".equals(key)){//用equals()方法进行判断
                entry.setValue("红葡萄");//用entry的setValue()方法改变获取的键所对应的的值
            }
        }
        System.out.println(map);
    }

二.泛型

泛型的本质是参数化类型，即所操作的数据类型被指定为一个参数，可以提高程序的类型安全。
（一）泛型类和泛型接口
泛型类：
代码示例：

    //T1,T2为类型参数
    public class Pointer {
        //构造函数
    }

    public class Launcher {
        public static void main(String[] args){
            Pointer p=new Pointer();
            Pointer p1=new Pointer<>();
            //必须用引用类型，不能用基本类型，区分Interger和int
            //区分Float和float
            //在最新版本的JDK中，<>可有可无
        }
    }

泛型接口：
代码示例：

    //关键字interface
    public interface MyInterface  {
        //构造函数
    }

（二）泛型方法
代码示例：

    public class Pointer {
        private T1 x;
        private T2 y;
        //如若声明为静态的，static写在<>之前
        public  void setLocation(T1 x,T2 y){
            this.x=x;
            this.y=y;
            System.out.println("x="+ x+",y="+ y);
        }       
    }

    public class Launcher {
        public static void main(String[] args){
            Pointer p=new Pointer();
            p.setLocation("东经10度","北纬20度");
        }
    }

对泛型的理解还不够透彻，示例代码未必准确，还需多敲代码多练习。