您的位置：首页 > 职场人生

黑马程序员——集合——Collection和单列集合List

2015-08-22 23:34 615 查看
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！
-------



一.集合概述

1.为什么我们编程中需要集合

数组既可以存储基本数据类型，也可以存储引用类型。

它存储引用类型的时候叫对象数组。

我们需要对多个对象进行存储和获取。可以使用对象数组。

但是，如果对象的个数是变化的，对象数组就不能解决。

java就提供了集合类来解决。

2.集合和数组的区别?

A:长度问题

数组长度固定

集合长度可变

B:存储元素种类

一个数组只能存储同一种类型元素

一个集合可以存储不同类型的对象元素

C:存储元素类型

数组可以存储基本类型数据，也可以存储引用类型数据。

集合只能存储引用类型数据。

3.集合体系的由来：

多种集合的数据结构是不相同的，但是，它们有共性的功能。

通过不断的向上抽取，最终形成了集合的体系结构。

Collection

|--List

|--ArrayList

|--Vector

|--LinkedList

|--Set

|--HashSet

|--TreeSet

二.集合的跟接口Collection

1.Collection接口的功能：

A:添加功能

add(Object obj)

B:删除功能

remove(Object obj)

C:判断功能

contains(Object obj)

D:获取功能

Iterator iterator()

E:长度功能

size()

2.迭代器的概述

A:迭代器其实就是遍历集合的一种方式。

B:迭代器的使用：

迭代器不能单独使用，它依赖于集合而存在。

C:使用步骤

a:通过集合对象调用iterator()方法得到迭代器对象。

b:通过迭代器对象的hasNext()方法判断是否有元素。

c:通过迭代器对象的next()获取元素。

D:使用原理：

是以内部类形式存在的。

3.集合的使用步骤：

A:非自定义对象集合的使用步骤

a.创建集合对象

b.创建元素对象

c.把元素添加到集合中

d.通过集合对象调用iterator()方法得到迭代器对象。

e.通过迭代器对象的hasNext()方法判断是否有元素。

f.通过迭代器对象的next()获取元素。

B:自定义对象集合的使用步骤

a.定义要存储到集合当中的类

b.创建集合对象：集合 集合引用变量 = new 集合();

c.创建要存储到集合当中的类的对象

d.调用集合方法，存储对应的对象

e.返回对应集合的迭代器

f.使用迭代器判断是否有下个元素

g.如果有下个元素则获取下个元素

4.存储学生对象并遍历：

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:FangSong_GB2312;font-size:18px;">package cn.bolg;

public class Student {
String name;
int age;

public Student() {
super();

}

public Student(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 "Student [name=" + name + ", age=" + age + "]";
}

}
</span></strong></span>
<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:FangSong_GB2312;font-size:18px;">package cn.bolg;

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

public class Demo {

/**
* 使用学生对象加入集合并操作
*/
public static void main(String[] args) {

// 创建Collection集合对象
Collection c = new ArrayList();

// 创建自定义元素对象
Student s = new Student("张三", 23);
Student s2 = new Student("李四", 22);
Student s3 = new Student("王五", 24);
Student s4 = new Student("赵六", 30);

// 将元素对象加入Collection集合中
c.add(s);
c.add(s2);
c.add(s3);
c.add(s4);

// 使用迭代器遍历集合
// 创建迭代器对象
Iterator iterator = c.iterator();
// 使用迭代器对象的hasNext方法和next方法获取元素
while (iterator.hasNext()) {
Student ss = (Student) iterator.next();
// 输出迭代器获取的元素
System.out.println(ss);
}

}

}
</span></strong></span>


三.单列集合List

1.List的特点：

List:元素有序(存入顺序和取出顺序一致),可重复。

2.List的特有功能：

A:添加功能

add(int index,Object obj)

B:删除功能

remove(int index)

C:获取功能

get(int index)

D:修改功能

set(int index,Object obj)

3.List特有的迭代器listIterator

A: 可以逆向遍历，但是要先正向遍历，一般不用。

B: 可以解决并发修改异常问题。

并发修改异常：在用迭代器遍历集合的时候，通过集合去修改了集合的元素。

解决方案：

a:通过列表迭代器遍历，通过列表迭代器修改集合。

b:通过集合遍历，通过集合修改集合。

listIterator案例：

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:FangSong_GB2312;font-size:18px;">package cn.bolg;

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

public class Demo4 {

/**
* 使用List特有的listIterator迭代器对List集合进行遍历以及添加元素
* 并使用listIterator迭代器特有的hasPrevious方法及previous方法 对List集合进行逆向遍历
*/
public static void main(String[] args) {

// 创建List集合对象
List list = new ArrayList();

// 创建字符串元素对象
String s = "邓超";
String s2 = "陈赫";
String s3 = "包贝尔";
String s4 = "李晨";

// 将字符串元素添加入List集合
list.add(s);
list.add(s2);
list.add(s3);
list.add(s4);

// 使用List特有的listIterator迭代器遍历List集合
// 创建迭代器对象
ListIterator listIterator = list.listIterator();

// 使用listIterator迭代器特有的方法给List添加元素"angelaBaby"
listIterator.add("angelaBaby");

// 使用迭代器的hasNext方法查看元素并用next方法获取元素
while (listIterator.hasNext()) {
String string = (String) listIterator.next();
// 依次输出获取到的集合元素
System.out.println(string);
}
System.out.println("+++++++++++++++++++");

// 使用listIterator的hasPrevious方法及previous方法对List集合进行逆向遍历
while (listIterator.hasPrevious()) {
String string2 = (String) listIterator.previous();
// 依次输出逆向获取到的集合元素
System.out.println(string2);
}

}

}
</span></strong></span>


4.List的三个子类的特点：

A.List:

|--ArrayList

底层数据结构是数组,查询快,增删慢。

线程不安全,效率高。

|--Vector

底层数据结构是数组,查询快,增删慢。

线程安全,效率低,一般不用。

|--LinkedList

底层数据结构是链表,查询慢,增删快。

线程不安全,效率高。

四.Collection和List及子类的遍历方式

Collection：

只能使用Iterator迭代器进行遍历

List：

方式一：使用普通for循环，通过索引进行遍历

方式二：使用listIterator迭代器遍历

ArrayList

方式一：使用普通for循环，通过索引进行遍历

方式二：使用listIterator迭代器遍历

Vector

方式一：使用普通for循环，通过索引进行遍历

方式二：使用返回Enumeration枚举进行遍历

LinkedList

方式一：使用普通for循环，通过索引进行遍历

方式二：使用listIterator迭代器遍历


案例：

List存储字符串并遍历。
<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:FangSong_GB2312;font-size:18px;">package cn.bolg;

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

public class Demo2 {

/**
* 将字符串对象加入List集合并遍历
*/
public static void main(String[] args) {

//创建List集合对象
List list = new ArrayList();

//创建字符串元素对象
String s="woaijava";
String s2="wolikejava";
String s3="wolovejava";

//将元素对象添加进List集合
list.add(s);
list.add(s2);
list.add(s3);

//对List集合进行遍历
//创建迭代器对象
Iterator iterator = list.iterator();
//使用迭代器的hasNext方法和next方法获取字符串元素
while (iterator.hasNext()) {
String st = (String) iterator.next();
//输出迭代器中获取到的元素
System.out.println(st);

}

}

}
</span></strong></span>


List存储自定义对象并遍历。

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:FangSong_GB2312;font-size:18px;">package cn.bolg;

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

public class Demo3 {

/**
* 自定义学生对象并加入List集合及遍历
*/
public static void main(String[] args) {

//创建List集合对象
List list = new ArrayList();

//创建学生对象
Student s= new Student("邓紫棋",25);
Student s2= new Student("邓俪",30);
Student s3= new Student("白百合",31);
Student s4= new Student("范冰冰",34);

//将学生对象添加进List集合
list.add(s);
list.add(s2);
list.add(s3);
list.add(s4);

//遍历List集合
//创建list的迭代器对象
Iterator iterator = list.iterator();
//使用迭代器的hasNext方法查找元素，next方法获取元素
while (iterator.hasNext()) {
Student sd = (Student) iterator.next();
//输出迭代器获取到的元素
System.out.println(sd);

}

}

}
</span></strong></span>
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航