java笔记杨枝11.11/11.12

一 List集合的子实现类的特点

ArrayList:
底层数据结构是数组的形式,满足数组结构的特点:查询快,增删慢
从线程安全问题来看:线程不安全的,不同步,执行效率高
由于ArrayList是List集合的自实现类,它元素可以重复,并且存储和取出一致

public class ArrayListDemo {

    public static void main(String[] args) {

        //创建一个ArrayList集合对象
        ArrayList array = new ArrayList() ;

        //添加元素
        array.add("hello") ;
        array.add("hello") ;
        array.add("world") ;
        array.add("world") ;
        array.add("java") ;
        array.add("java") ;

        //遍历元素:
        //1)获取迭代器对象
        Iterator it = array.iterator() ;
        while(it.hasNext()){
            String s = (String)it.next() ;
            System.out.println(s);
        }
    }
}

Vector:
底层数据结构是数组的形式,查询快,增删慢
从线程角度看:线程安全的类,同步,执行效率低
特有功能:
public void addElement(E obj)——->相当于:add(Object e)
public Enumeration elements()—–>相当于:Iterator iterator() ;
Enumeration接口:向量的组件枚举有两个方法
boolean hasMoreElements():——>相当于:hasNext()
Object nextElement():———–>相当于:next();

package org.westor.practice114;

import java.util.Enumeration;
import java.util.Vector;

public class Prac {
    public static void main(String[] args) {
      Vector v = new Vector() ;

        //添加元素
        //public void addElement(E obj)
        v.addElement("hello");
        v.addElement("hello");
        v.addElement("world");
        v.addElement("Java");

        //public Enumeration<E> elements()----->相当于:Iterator iterator() ;
        Enumeration en = v.elements() ;
        //遍历元素
        /**
         * boolean hasMoreElements():------>相当于:hasNext()
        Object nextElement():----------->相当于:next();
         */
        while(en.hasMoreElements()){
            //获取元素
            String s = (String)en.nextElement() ;
            System.out.println(s);
        }
}
}

LinkedList:
底层数据结构是链接列表,特点:查询慢,增删快
从线程角度看:线程不安全的一个类,不同步,执行效率高
特有功能:
添加功能:
public void addFirst(E e)将指定元素插入此列表的开头。
public void addLast(E e)将指定元素添加到此列表的结尾。
获取功能:
public Object getFirst()返回此列表的第一个元素
public Object getLast()返回此列表的最后一个元素。
删除功能:
public Object removeFirst()移除并返回此列表的第一个元素。
public Object removeLast()移除并返回此列表的最后一个元素。

二 泛型

把数据类型的明确工作提供提前到了创建对象或者是调用方法的时期明确的一种特殊类型.参数化类型,可以像参数一样进行传递
格式:
<引用类型>:泛型只能放引用类型
泛型好处:
1)将运行时期异常提前到了编译时期
2)解决了黄色警告线问题
3)获取数据的时候,不用强制类型转换了
一般情况:泛型可以应用在接口,类,或者方法上;主要用在集合中比较多!

public class GenericDemo2 {

    public static void main(String[] args) {

        //创建一个ArrayList集合对象
        ArrayList<String> array = new ArrayList<String>() ;//jdk7特性:泛型推断!:建议:后面永远给出类型

        //给集合中添加元素
        array.add("hello") ;
        array.add("world") ;
        array.add("java") ;
//      array.add(10) ;

        //获取迭代器对象并遍历
        Iterator<String> it = array.iterator() ;
        //遍历
        while(it.hasNext()){
            //不用强制类型转换了
            String s = it.next() ;
            System.out.println(s);
        }

    }
}

泛型的高级:通配符

public class GenericDemo {

    public static void main(String[] args) {

        //创建Collection集合的对象
        //最起码:前后的数据类型保持一致
//      Collection<Object> c1 = new ArrayList<Animal>() ;
//      Collection<Object> c2 = new ArrayList<Cat>() ;
//      Collection<Object> c3 = new ArrayList<Dog>() ;
        Collection<Object> c3 = new ArrayList<Object>() ;


        // <?> :可以是任意类型,包括Object类型以及任意的Java类
        Collection<?> c4 = new ArrayList<Object>() ;
        Collection<?> c5 = new ArrayList<Animal>() ;
        Collection<?> c6 = new ArrayList<Cat>() ;
        Collection<?> c7 = new ArrayList<Dog>() ;

        //<? extends E>:向下限定,E类型以及E类型的子类
        Collection<? extends Object> c8 = new ArrayList<Object>() ;
        Collection<? extends Animal> c9 = new ArrayList<Animal>() ;
//      Collection<? extends Animal> c10 = new ArrayList<Object>() ;
        Collection<? extends Object> c11 = new ArrayList<Cat>() ;

        //<? super E>:向上限定,E类型以及E类型的父类
        Collection<? super Animal> c12 = new ArrayList<Object>() ;
        Collection<? super Animal> c13 = new ArrayList<Animal>() ;
//      Collection<? super Animal> c14 = new ArrayList<Dog>() ;
    }
}

//自定义两个类
class Animal{

}

class Cat extends Animal{

}
class Dog extends Animal{

}

三 增强for循环

书写格式:
for(集合或者数组中的数据类型 变量名:集合或者数组的对象名){
输出变量名;
}
增强for循环的弊端:
遍历数组或者集合的时候,数组对象或者集合对象不能为null
如果对象为空,一般加上非空判断

四 Set集合

底层数据结构是一个哈希表,能保证元素是唯一的,元素不重复!
它通过它的子实现了HashSet集合去实例化,HashSet集合底层是HashMap集合的实例!
List集合和Set集合的区别?
Set:元素是唯一的,无序性(存储和取出不一致)
List:元素可以重复,有序性(存储和取出一致
由于现在是自定义对象:在当前自定义对象的类中没有重写两个方法
hashCode和equals()方法;HashSet底层是依赖于这两个实现来保证元素的唯一性!

public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

LinkedHashSet集合:
由哈希表保证元素的唯一性
由链接列表来保证元素的有序性!
TreeSet集合底层是依赖于TreeMap的实例,而TreeMap是依赖红黑树结构实现的
分两种:
自然排序
比较器排序
这种排序的使用取决于开发者是用什么样的构造方法
对于TreeSet集合存储自定义对象必须实现一个接口:compareable接口
要使用TreeSet集合的比较器排序:
依赖于构造方法:
public TreeSet(Comparator comparator）
两种方式实现比较器排序:
Comparator接口作为形式参数进行传递,需要该接口的子实现类对象