黑马程序员——Java基础---集合

原创 2015年07月10日 16:06:08

——- android培训java培训、期待与您交流! ———-
*为什么出现集合类?
面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。

数组合集合类同时容器,有何不同?
数组虽然也可以储对象,但长度是固定的,集合长度是可变的,数组中可以存储基本数据类型,集合只能存储对象

集合类的特点
集合只用于存储对象,结合长度是可变的,集合可以存储不同类型的对象。
常用共性方法演示:

package Collection;

import java.util.ArrayList;

public class CollectionDemo {

    public static void main(String[] args) {

        //创建一个结合容器,使用collection接口的子类,ArrayList
        ArrayList al=new ArrayList();

        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");

        //打印原集合
        System.out.println(al);

        //删除元素
        al.remove(1);
        al.remove("java01");

        //判断元素
        System.out.println("java01是否存在:"+al.contains("java01"));
        System.out.println("集合是否为空?"+al.isEmpty());

        //获取个数,集合长度
        System.out.println("size:"+al.size());

        //打印改变后的集合
        System.out.println(al);

        method_1();


    }
    public static void method_1()
    {

        ArrayList al1=new ArrayList();
        al1.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");


        ArrayList al2=new ArrayList();
        al2.add("java02");
        al2.add("java03");
        al2.add("java07");
        al2.add("java08");

        //取交集,al1中只会保留和al2
        System.out.println(al1.retainAll(al2));
        System.out.println(al1);
        System.out.println(al2);


    }

}

结果:
这里写图片描述

迭代器:
其实就是集合的取出元素的方式

package Collection;

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

public class IteratorDemo {

    public static void main(String[] args) {

        //创建ArrayList对象
        ArrayList<String> al= new ArrayList<String>();

        //向里面添加五个元素
        al.add("person1");
        al.add("person2");
        al.add("person3");
        al.add("person4");
        al.add("person5");

        //用Iterator遍历输出
        Iterator<String> it=al.iterator();

        //遍历取出所有元素
        while(it.hasNext())
        {
            System.out.println(it.next());
        }

    }

    }

结果:这里写图片描述
collection

    |--List:元素是有序的,元素可以重复,因为该集合体系有索引
        |--ArrayList   :底层的数据结构使用的是数组结构,特点:查询速度很快,但是增删稍慢。线程不同步
        |--LinkedList:底层使用的是链表数据结构        特点:增删速度很快,查询稍慢。
        |--Vector   :底层是数组数据结构    线程同步,被ArrayList替代了。

    |--Set:元素是无序的(存入和取出的顺序不一致),元素不可以重复
        |--HashSet:底层数据结构是哈希表。
            HashSet是如何保证元素的唯一性呢?
            是通过元素的两个方法,haseCode和equals来完成,如果元素的HashCode值相同,才会判断    equals是否为true,如果元素的HashCode值不同,不会调用equals.
            注意:对于判断元素是否存在,以及删除操作,依赖的是元素的hashCode和equals方法。
        |--
        set集合的功能和Collection一样
        |--TreeSet 可以对集合中元素进行排序,底层数据结构是二叉树,保证元素唯一性的依据:
        CompareTo方法return 0
            TreeSet排序的第一种方式:让元素自身具备比较性,元素需要实现Comparable接口,
            覆盖compareTo方法,这种方式也称为元素的自然顺序,或者叫默认顺序
            TreeSet的第二种排序方式:当元素自身不具备比较性时,或者具备的比较性不是所
            需要的,这时就需要让集合自身具备比较性。在集合初始化时,就有了比较方式。
            当两种方式都存在时,以比较器为主。
            定义一个类,实现comparator接口,覆盖compare方法
|——Map
该集合存储键值对,一对一对往里存,而且要保证键额唯一性。
    |--Hashtable:底层是哈希表数据结构,不可以存入null键和null值,该集合是同步的。jdk1.0效率低
    |———HashMap :底层哈希表数据结构,允许使用使用null键和null值,该集合是不同步的。jdk1.2效率高
    |————TreeMap:底层是二叉树结构,线程不同步,可以用于给map集合的值进行排序。
Map和set很像Set底层使用了Map集合。

List:
特有方法,凡是可以操作角标的方法都是该体系特有的方法。
增:
add(index,element)
add(index,Collection);
删:
remove(index);
改:
set(index,element)
查:
get(index)
subList(from,to)
ListIterator();
List集合特有的迭代器:ListIterator是Iterator的子接口

在迭代是,不可以通过集合对象的方法操作集合中的元素,因为会发生ConcurrentModificationException异常。所以,在迭代时,只能用迭代器的方法操作元素,可Iterator的方法时有限的,只能对元素进行判断,取出,删除的操作,如果想要其他的操作如:添加,修改等,就需要使用其子接口ListIterator该接口只能通过List集合的ListIterator方法获取

List中常用方法以及特有ListIterator迭代器的演示:

package Collection;

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

public class ArrayListDemo {

    public static void main(String[] args) {
        ArrayList al=new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");

        System.out.println("原集合是:"+al);

        //在指定位置上添加元素
        al.add(0,"java05");

        //删除指定位置上元素
        al.remove(2);

        //修改元素:
        al.set(3,"java10" );

        //通过角标获取元素
        System.out.println("角标为1的元素是:"+al.get(1));

        //现集合是
        System.out.println("现集合是:"+al);


        //list集合特有的取出方式:遍历
        for(int x=0; x<al.size(); x++)
        {
            System.out.println("al("+x+")="+al.get(x));
        }

        //通过indexOf获取对象的位置
        System.out.println("java03所在角标数:"+al.indexOf("java03"));

        List sub=al.subList(0, 3);
        System.out.println("0到3的元素为"+sub);
        listIterator();
    }
    public static void listIterator()
    {
        //演示List特有迭代器
        ArrayList al=new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");

        ListIterator li=al.listIterator();
        while(li.hasNext())
        {
            Object obj=li.next();

            if(obj.equals("java02"))
            li.add("java06");
        }
        System.out.println("迭代中添加其他元素后的集合:"+al);
    }

}

输出结果:这里写图片描述

Vector
枚举是Vector特有的取出方式,枚举和迭代是一样的,因为枚举的名称以及方法名称都过长,所以被被迭代器取消了。

package Collection;

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

public class VectorDemo {

    public static void main(String[] args) {
        Vector v=new Vector();
        v.add("java01");
        v.add("java02");
        v.add("java03");
        v.add("java04");

        Enumeration en=v.elements();
        while(en.hasMoreElements())
        {
            System.out.println(en.nextElement());
        }
    }

}

结果:这里写图片描述

LinkedList
特有方法:
addFirst()
addLast()
getFirst()
getLast()
获取元素,但不删除元素,如果集合中没有元素,会出现NoSuchElementException

removeFirst()
removeLast()
获取元素,但是元素被删除,如果集合中没有元素,会出现NoSuchElementException

在JDK1.6出现了替代方法
offerFirst()
offerLast()

PeekFirst()
peekLast()

poolFirst()
poolLast()
获取元素,但是元素被删除,如果集合中没有元素,会返回null。

package Collection;

import java.util.LinkedList;

/**
 * 使用LinkedList模拟一个堆栈或者队列数据结构
 * 
 * 堆栈:先进后出
 * 队列:先进先出
 * @author Administrator
 *
 */

class DuiLie
{
    private LinkedList link;
    DuiLie()
    {
        link=new LinkedList();
    }
    public   void myAdd(Object obj)
    {
         link.addFirst(obj);
    }
    public Object myGet()
    {
        return link.removeLast();
    }
    public boolean isNull()
    {
        return link.isEmpty();
    }
}

public class LinedListDemo {

    public static void main(String[] args) {
        DuiLie dl=new DuiLie();
        dl.myAdd("java01");
        dl.myAdd("java02");
        dl.myAdd("java03");
        dl.myAdd("java04");

        while(!dl.isNull())
        {
            System.out.println(dl.myGet());
        }


    }

}

结果:这里写图片描述

package Collection;

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

//去除ArrayList集合中的重复元素
public class ArrayListTest {

    public static void main(String[] args) {
        //创建一个集合
        ArrayList al=new ArrayList();

        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        al.add("java03");
        al.add("java04");

        System.out.println("原集合是:"+al);

        //去除之后
        al=singleElement( al);
        System.out.println("去除重复元素后:"+al);





    }
    public static ArrayList singleElement(ArrayList al)
    {
        //定义一个临时容器
        ArrayList newal=new ArrayList();
        Iterator it=al.iterator();
        while(it.hasNext())
        {
            Object  obj=it.next();
            if(!newal.contains(obj))
            {
                newal.add(obj);
            }
        }

        return newal;

    }

}

这里写图片描述

package Collection;

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

/**
 * 将自定义元素存到ArrayList集合中,并去除重复元素
 * 比如:存人对象,同姓名同年龄,视为同一个人,为重复元素
 * @author Administrator
 *
 */
class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public void setName(String name)
    {
        this.name=name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    //覆盖equals方法,建立自己的特有比较方法
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Person))
            return false;

        Person p=(Person)obj;
        return this.name.equals(p.name) && this.age==p.age;
    }

}
public class ArrayListTest2 {

    public static void main(String[] args) {
        ArrayList al=new ArrayList();

        al.add(new Person("lisi01",30));
        al.add(new Person("lisi02",53));
        al.add(new Person("lisi03",23));
        al.add(new Person("lisi03",23));

        al= singleElement(al);

        Iterator it=al.iterator();
        while(it.hasNext())
        {
            Person p=(Person)it.next();
            System.out.println(p.getName()+"..."+p.getAge());
        }
    }

    //去除重复元素
    public static ArrayList singleElement(ArrayList al)
    {
        //定义一个临时容器
        ArrayList newal=new ArrayList();

        Iterator it=al.iterator();
        while(it.hasNext())
        {
            Object  obj=it.next();

            if(!newal.contains(obj))//contains的底册实现原理是equals
            {
                newal.add(obj);
            }
        }

        return newal;

    }

}

这里写图片描述

package Collection;

import java.util.HashSet;
import java.util.Iterator;

/*
 * 往hashset集合中存入自定义对象,姓名和年龄相同为同一个元素
 */
class Person1
{
    private String name;
    private int age;
    Person1(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public void setName(String name)
    {
        this.name=name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int hashCode()
    {
        return name.hashCode()+age;
    }

    //覆盖equals方法,建立自己的特有比较方法
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Person1))
            return false;

        Person1 p=(Person1)obj;
        return this.name.equals(p.name) && this.age==p.age;
    }

}
public class HashSetTest {

    public static void main(String[] args) {
        HashSet hs=new HashSet();

        hs.add(new Person1("a2",11));
        hs.add(new Person1("al",12));
        hs.add(new Person1("al",12));
        hs.add(new Person1("a3",14));

        Iterator it=hs.iterator();
        while(it.hasNext())
        {
            Person1 p=(Person1)it.next();
            System.out.println(p.getName()+"::"+p.getAge());
        }

    }

}

这里写图片描述

TreeSet

package Collection;
/**
 * 需求:往TreeSet集合中存储自定义对象学生,按照学生的年龄进行排序
 */
import java.util.Iterator;
import java.util.TreeSet;

class Student implements Comparable//该接口强制让学生具备比较性
{
    private String name;
    private int age;

    Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public void setName(String name)
    {
        this.name=name;
    }
    public void setAge(int age)
    {
        this.age=age;
    }

    public  String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    @Override
    public int compareTo(Object o) {
        if(!(o instanceof Student))
            throw new RuntimeException("不是学生对象");

        Student s=(Student)o;
        if(this.age>s.age)
            return 1;

        if(this.age==s.age)
        {
            return this.name.compareTo(s.name);
        }
        return -1;
    }
} 
public class TreeSetTest {

    public static void main(String[] args) {

        TreeSet tr=new TreeSet();

        tr.add(new Student("lisi08",22));
        tr.add(new Student("lisi03",21));
        tr.add(new Student("lisi02",22));
        tr.add(new Student("lisi05",35));


        Iterator it=tr.iterator();

        while(it.hasNext())
        {
            Student stu=(Student)it.next();
            System.out.println(stu.getName()+".."+stu.getAge());
        }
    }

}

结果:这里写图片描述

注意:排序时,当主要条件相同时,一定要判断次要条件。

package Collection;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/*
 * 练习:按照字符串长度排序
 */
public class TreeSetTest1 {

    public static void main(String[] args) {

        TreeSet ts= new TreeSet( new myBijiao());
        ts.add("hrt");
        ts.add("z");
        ts.add("dkola");
        ts.add("abcf");
        ts.add("mkay");

        Iterator it=ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }

    }

}
class myBijiao implements Comparator
{

    public int compare(Object o1, Object o2) {
        String s1=(String)o1;
        String s2=(String)o2;
        if(s1.length()>s2.length())
            return 1;
        if(s1.length()<s2.length())
            return -1;  
        else
            return s1.compareTo(s2);


    }

}

这里写图片描述

泛型

JDK1.5版本以后出现新特性,用于解决安全问题,是一个安全机制

好处:1.将运行时期出现的问题ClassCastException,转移到了编译时期,方便于程序员解决问题,让运行时期问题减少,安全。
2.避免了强制转换麻烦。

package Collection2;

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

public class GenericDemo {

    public static void main(String[] args) {
        ArrayList<String>  al=new ArrayList<String>();

        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");

        Iterator<String> it=al.iterator();

        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }

}

这里写图片描述

泛型格式:通过<>来定义要操作的引用数据类型
在使用java提供的对象时,什么时候定义泛型呢?
通常在集合中很常见,只要见到<>就要定义泛型。
当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可。

泛型类:
什么时候定义泛型类?
当类中药操作的引用数据类型不确定的时候,早期定义Object来完成扩展,现在定义泛型类完成扩展。

示例:
package Collection2;

class Worker
{

}
class Util
{
private QQ q;
public void setObject(QQ q)
{
this.q=q;
}
public QQ getObject()
{
return q;
}
}
public class GenericDemo1 {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    Util<Worker> u=new Util<Worker>();
    u.setObject(new Worker());
    u.getObject();

}

}

泛型方法:
泛型类定义的泛型,在整个类中有效,如果被方法使用,那么泛型类的对象要明确操作的具体类型后,所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义方法上。
特殊之处:静态不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。

package Collection2;

class Demo
{
    //泛型方法
    public<T> void show(T t)
    {
        System.out.println("show"+t);
    }
    public<Q> void print(Q q)
    {
        System.out.println("print:"+q);
    }
}
public class GenericDemo2 {

    public static void main(String[] args) {
        Demo d=new Demo();
        d.show("hello");
        d.print(3);
    }

}

这里写图片描述

静态泛型方法:
这里写图片描述

泛型接口:
这里写图片描述

?通配符,也可以理解占位符
泛型限定:
? extends E:可以接受E类型或者E的子类,上限
? super E:可以接受E类型或者E的父类型,下限
示例:

package Collection2;

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

class Person
{
    private String name;
    Person(String name)
    {
        this.name=name;
    }
    public String getName()
    {
        return name;
    }
}
class Student extends Person
{
    Student(String name) {
        super(name);
    }

}
public class GenericDemo4 {

    public static void main(String[] args) {
    ArrayList<Person> al=new ArrayList<Person>();

    al.add(new Person("wangwu01"));
    al.add(new Person("wangwu01"));
    al.add(new Person("wangwu03"));
    al.add(new Person("wangwu04"));

    ArrayList<Student> al1=new ArrayList<Student>();
    al1.add(new Student("lisi01"));
    al1.add(new Student("lisi02"));
    al1.add(new Student("lisi03"));
    al1.add(new Student("lisi04"));

    print(al);
    print(al1);
    }
                                        //泛型限定
    public static void print(ArrayList<? extends Person> al) //或者可以写 ?super student
    {
        Iterator <? extends Person> it=al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
    }


}

这里写图片描述

Map集合
方法:
1.添加:
put(k key, v value)
putAll(Map

package Collection2;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo2 {

    public static void main(String[] args) {
         Map<String,String> map=new HashMap<String,String>();

         map.put("01", "zhangsan1");
         map.put("02", "zhangsan2");
         map.put("03", "zhangsan3");
         map.put("04", "zhangsan4");

         //获取所有键的set集合
         Set<String> keyset=map.keySet();

         //通过set集合获取其迭代器
         Iterator<String> it=keyset.iterator();

         while(it.hasNext())
         {
             String key=it.next();

             //通过键,用get方法获取对应的值
             String value=map.get(key);
             System.out.println("key:"+key+"value:"+value);
         }



    }

}

这里写图片描述

entrySet示例:

package Collection2;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class MapDemo3 {

    public static void main(String[] args) {
         Map<String,String> map=new HashMap<String,String>();

         map.put("01", "zhangsan1");
         map.put("02", "zhangsan2");
         map.put("03", "zhangsan3");
         map.put("04", "zhangsan4");

         Set<Map.Entry<String, String>>  s=map.entrySet();

         //通过set得到迭代器
         Iterator<Map.Entry<String, String>>  it=s.iterator();
         while(it.hasNext())
         {
             Map.Entry<String, String> ss=it.next();//迭代出Map.Entry接口
             String key=ss.getKey();//通过接口张方法获取key
             String value=ss.getValue();//通过接口中方法获取value

             //打印所有key以及value
             System.out.println("key:"+key+" value:"+value);
         }

    }

}

这里写图片描述

练习:

package Collection2;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

/**
 * 每一个学生都有对应的归属地,学生Student,地址String,学生属性:姓名,年龄,
 * 注意:姓名和年龄相同的的视为同一个学生,保证学生的唯一性。
 * @author Administrator
 *1,描述学生
 *2.定义map容器,将学生视为键,地址作为值,存入。
 *3.获取Map集合中的元素、
 *
 */
class Students implements Comparable<Students>
{
    private String name;
    private int 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 int hashCode() {
        return name.hashCode()+age*37;
    }
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Students))
            throw new  ClassCastException("类型不匹配");

        Students s=(Students)obj;
        return this.name.equals(s.name) && this.age==s.age;

    }
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    public Students(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public int compareTo(Students o) {
        int num=new Integer(this.age).compareTo(new Integer(o.age));
        if(num==0)
            return this.name.compareTo(o.name);
        return num;
    }   
}
public class MapTest {

    public static void main(String[] args) {

        HashMap<Students,String> map=new HashMap<Students,String>();

        map.put(new Students("lisi01",21),"beijing");
        map.put(new Students("lisi02",22),"shanghai");
        map.put(new Students("lisi03",23),"nanjing");
        map.put(new Students("lisi04",24),"xinjiang");

        Set<Students> s =map.keySet();
        Iterator<Students>  it=s.iterator();
        while(it.hasNext())
        {
            Students stu=(Students)it.next();
            String value=map.get(stu);
            System.out.println("key: "+stu+" value:"+value);
        }

    }

}

这里写图片描述

练习二:

package Collection2;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

/*
 * 需求:对学生对象分的年龄进行升序排序,
 * 因为数据是以键值对形式存在的,所以要使用可以排序的map集合,TreeMap
 */
public class TreeMapTest {

    public static void main(String[] args) {

        //先按比较器排序,再按元素自身的comparable的排序
        TreeMap<Students,String> tm=new TreeMap<Students,String>(new Mybj());

        tm.put(new Students("lisi05",27),"beijing");
        tm.put(new Students("lisi03",21),"shanghai");
        tm.put(new Students("lisi04",22),"nanjing");
        tm.put(new Students("lisi02",28),"xinjiang");

        Set<Map.Entry<Students,String>> entrySet =tm.entrySet();
        Iterator<Map.Entry<Students,String>>  it=entrySet.iterator();
        while(it.hasNext())
        {
            Map.Entry<Students,String> me=it.next();
            Students stu=me.getKey();
            String   addr=me.getValue();
            System.out.println("key:"+stu+"value:"+addr);
        }


    }

}

class Mybj implements Comparator<Students>
{

    public int compare(Students o1, Students o2) {
        int num=o1.getName().compareTo(o2.getName());
        if(num==0) 
        {
            return  new Integer(o1.getAge()).compareTo(new Integer(o2.getAge()));
        } 

        return num;
    }

}

这里写图片描述

版权声明:本文为博主原创文章,未经博主允许不得转载。

黑马程序员——Java基础之集合框架

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------             Java基础之集合框架 1.什么是集合,集合的作用:        ...

黑马程序员——java基础---集合框架

 ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 集合框架 定义:为了方便对多个对象的操作,就对对象进行存储,集合就是...

黑马程序员——java基础知识之泛型、集合(Map、工具类等)

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——- (一)、泛型...

黑马程序员——JAVA基础拾遗之泛型和集合框架(二)

泛型 JDK1.5以后出现的新特性,用于解决安全问题,是个类型安全机制, 先看以下的代码         ArrayList l = new ArrayList();         ...

黑马程序员——JAVA基础------集合框架(四)----Map集合

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! —— 一、Map接口 public interface Map 将键映射到值的对象,一个映射不能包含重复的键;...

黑马程序员——JAVA基础------集合框架(二)----Set接口

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——一、Set接口1 、 Set 接口public interface Set extends Collection一 ...

黑马程序员——java基础(集合框架、泛型)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 第九章:java基础(集合框架、泛型)   本章概述: 第一部分:集合框架 第二部分:集合框...

黑马程序员——Java基础--集合(五)

-----------android培训、java培训、java学习型技术博客、期待与您交流!------------ 第五讲 Map 一、概述         存储的是俩个对象,映射键值对(a 1...
  • c_san_6
  • c_san_6
  • 2015年07月06日 21:56
  • 377

黑马程序员——java基础---集合(第14天)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流----- 集合 一、概述 1、为什么会出现这个多余的容器呢? 因为每一个容器对数据的存储方式有所不同。 这个...

黑马程序员——Java基础---集合类(上)

------- android培训、java培训、期待与您交流! ---------- 集合类知识目录: 一、集合概述 1、对象数组的概述和使用 2、对象数组的内存(图解) 3、集合的由...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:黑马程序员——Java基础---集合
举报原因:
原因补充:

(最多只允许输入30个字)