黑马程序员__集合_List_Set_泛型

时间：2015-05-12 09:23:57 阅读：247 评论：0 收藏：0 [点我收藏+]

标签：黑马程序员编程 java 集合

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

<集合>

1.集合：集合可以理解为一种容器, 长度可变, 可以存储任意类型的对象。

2.集合的分类：

集合框架的构成及分类：

技术分享

单列集合：Collection，双列集合：Map。

        1).Collection有两个子接口分别是List、Set。
       List: 可重复, 有存储顺序,有索引
              ArrayList
               LinkedList
               Vector

         Set: 不可重复, 没索引,存取无序
                HashSet
                TreeSet
                LinkedHashSet HashSet的子类

           2).Map双列集合
                HashMap
               TreeMap
               Hashtable
                LinkedHashMap

3.数组和集合的区别
           1).数组既可以存储基本数据类型,也可以存储引用数据类型,存储基本数据类型存储值,存储引用数据类型存储的是地址值，集合只能存储引用数据类型。
           2).数组的长度一旦初始化就不可以改变
              集合的长度是可变的。

4.集合的常用方法
  add(Object obj)    向集合中添加一个元素到最后的位置
  get(int index)        获取集合中指定位置的元素
  size()                    获取集合的长度
  add(int index, Object obj) 向集合中添加一个元素到指定位置
  set(int index, Object obj) 把集合中指定位置的元素替换
  remove(int index)               删除集合中指定位置的元素
  remove(Object obj)            删除集合中包含的obj对象

<List>

1.List有三个子类：ArrayList，LinkedList，Vector。
   1).ArrayList
      底层数据结构是数组，查询和修改快，增删慢，线程不安全，效率高。
       Vector
       底层数据结构是数组，与ArrayList相比线程安全，效率低。
       LinkedList
      底层数据结构是链表，查询和修改慢，增删快，线程不安全，效率高。
      LinkedList可以很方便的操作头和尾。

2.迭代集合
      for循环:  从0循环到集合的size()-1, 每次获取其中一个
      迭代器:   调用iterator()方法获取迭代器, 使用hasNext()判断是否包含下一个元素, 使用next()获取下一个元素
      增强for循环: for (类型变量名 : 容器) { 循环体 } 容器中有多少个元素就执行多少次循环体, 每次循环变量指向容器中不同的元素(1.5新特性)。

[java]view
 plaincopy

<span style="font-size:18px;">class Demo{ </span>  

[java]view
 plaincopy

<span style="font-size:18px;">        public static void main(String[] args) {  

        ArrayList list = new ArrayList();  

        list.add("a");  

        list.add("b");  

        list.add("c");  

        list.add("d");  

        list.add("e");  

            for(int i=0;i<list.size();i++){</span>

[java]view
 plaincopy

<span style="font-size:18px;">                  System.out.println(list.get(i));} </span>  

[java]view
 plaincopy

<span style="font-size:18px;">  

        ListIterator lit = list.listIterator();  

                while(lit.hasNext()) {  

            System.out.println(lit.next());  

        }}</span>

[java]view
 plaincopy

<span style="font-size:18px;">           for(Object obj : list){</span>  

[java]view
 plaincopy

<span style="font-size:18px;">                System.out.println(obj);}  

        }}</span>  

3.删除

[java]view
 plaincopy

public class Demo7_Delete {  

    /** 

     * @param args 

     */  

    public static void main(String[] args) {  

        //demo1();  

        ArrayList list = new ArrayList();  

        list.add("a");  

        list.add("a");  

        list.add("b");  

        list.add("b");  

        list.add("c");  

        list.add("d");  

        /*for(int i = 0; i < list.size(); i++) { //普通for循环可以删除,删除的时候索引要--         

            Object obj = list.get(i); 

            if(obj.equals("a")) { 

                list.remove(i--); 

            } 

        }*/  

        Iterator it = list.iterator();  

        while(it.hasNext()) {           //迭代可以删除,但是必须用迭代器的删除方法  

            Object obj = it.next();     //如果用集合的删除方法,会出现并发修改异常ConcurrentModificationException  

            if(obj.equals("b")) {  

                //list.remove("b");    //错误  

                it.remove();  

            }  

        }  

}

普通for删除

技术分享

<泛型>(1.5版本的新特性)

1.泛型能将运行时期的错误,转移到了编译时期，去除黄色警告提示，但是只能放该类型或该类型的子类型对象,其他的都不允许放

[java]view
 plaincopy

public static void main(String[] args) {  

        demo1();  

        ArrayList<Integer> list = new ArrayList<>();        //1.7新特性，菱形泛型  

        list.add(123);  

        System.out.println(list);  

    }  

    private static void demo1() {  

        ArrayList<Person> list = new ArrayList<Person>();  

        list.add("a");  

        list.add(123);  

        Iterator<Person> it = list.iterator();  

        while(it.hasNext()) {  

            Person p = it.next();  

            System.out.println(p.getName() + "..." + p.getAge());  

        }  

    }  

}

<Set>

1.Set     不可重复, 没索引,无序
        HashSet              使用哈希算法去重复, 效率高, 但元素无序
         TreeSet               TreeSet是用排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列
        LinkedHashSet HashSet的子类, 原理相同, 除了去重复之外还能保留存储顺序

2.HashSet(LinkedHashSet)
1).HashSet原理
我们使用Set集合都是需要去掉重复元素的, 如果在存储的时候逐个equals()比较, 效率较低,哈希算法提高了去重复的效率, 降低了使用equals()方法的次数。当HashSet调用add()方法存储对象的时候, 先调用对象的hashCode()方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象。如果没有哈希值相同的对象就直接存入集合。如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较,比较结果为false就存入, true则不存。
2).将自定义类的对象存入HashSet去重复
类中必须重写hashCode()和equals()方法。hashCode(): 属性相同的对象返回值必须相同, 属性不同的返回值尽量不同(提高效率)。 equals(): 属性相同返回true, 属性不同返回false,返回false的时候存储。

[java]view
 plaincopy

ublic class Person implements Comparable<Person> {   //往TreeSet集合添加自定义类，自定义类需实现Comparable接口  

    private String name;  

    private int age;  

    public Person(){  

        super();  

    }  

    public Person(String name, int age) {  

        super();  

        this.name = name;  

        this.age = age;  

    }  

    public String getName() {  

        return name;  

    }  

    public void setName(String name) {  

        this.name = name;  

    }  

    public int getAge() {  

        return age;  

    }  

    public void setAge(int age) {  

        this.age = age;  

    }  

    @Override  

    public String toString() {  

        return "Person [name=" + name + ", age=" + age + "]";  

    }  

    @Override  

    public int hashCode() {                   //重写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) {         //重写equals的方法  

        if (this == obj)  

            return true;  

        if (obj == null)  

            return false;  

        if (getClass() != obj.getClass())  

            return false;  

        Person other = (Person) 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;  

    }  

    @Override  

    public int compareTo(Person o){            //重写compareTo方法  

        int num=this.age-o.age;  

        return num==0?this.name.compareTo(o.name):num;  

    }

3).迭代
调用iterator()方法得到Iterator, 使用hasNext()和next()方法
增强for循环, 只要可以使用Iterator的类都可以用

[java]view
 plaincopy

class Demo{  

public static void main(System[] args){  

HashSet<Person> hs = new HashSet<>()  

hs.add(new Person("张三"),23);  

hs.add(new Person("李四"),24);  

hs.add(new Person("王五"),25);  

hs.add(new Person("赵六"),26);  

Iterator<Person> it = hs.iterator();  

while(it.hasNext()){  

System.out.println(it.next());}  

}  

}  

for(Person p : hs){           //增强for循环  

System.out.println(p);  

}

4.TreeSet
1).TreeSet是用来排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列.
2).使用方式
     自然顺序(Comparable)
      TreeSet类的add()方法中会把存入的对象提升为Comparable类型，调用对象的compareTo()方法和集合中的对象比较，根据compareTo()方法返回的结果进行存储。
    比较器顺序(Comparator)
   创建TreeSet的时候可以制定一个Comparator，如果传入了Comparator的子类对象, 那么TreeSet就会按照比较器中的顺序排序
   add()方法内部会自动调用Comparator接口中compare()方法排序
    两种方式的区别
   TreeSet构造函数什么都不传, 默认按照类中Comparable的顺序，TreeSet如果传入Comparator, 就优先按照Comparator

[java]view
 plaincopy

class Demo{  

TreeSet<Person> ts = new TreeSet<>(new Comparator(){  

public int compare(Person p1 , Person p2){  

int num = p1.name.compare(p2.namm);  

return num==0?p1.age-p2.age:num}});  

ts.add("张三"，23);  

ts.add("李四"，24);  

ts.add("王五"，25)；  

ts.add("赵六"，26);  

System.out.println(ts);}

黑马程序员__集合_List_Set_泛型

标签：黑马程序员编程 java 集合

原文地址：http://blog.csdn.net/haojude/article/details/45654605

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行