Collection-集合的介绍

集合Collection之List集合

集合是一个容器。和比较来看集合的特点。数组有什么特点? 1.有顺序 2.定长 3.类型单一

集合特点: 1.有顺序也可以没顺序 2.集合长度可以随着元素的增加而增加 3.集合中可以装入任何Object

java中的集合类都在java.util包下，java中的集合元素全是Object类型的。

集合体系图

Collection——List

List——1，LinkedList

2，ArrayList

3，Vector——Stack

Collection——Set

Set——1，HashSet——LinkedHashSet

2，TreeSet

Map——1，HashMap

——2，TreeMap

Collection集合之List集合

List集合的特点:有顺序可重复

List是继承自Collection，Collection中的方法在List中都是存在。

List集合中的特性方法:

因为List集合是有顺序的，我们可以对其元素进行精确控制，通过索引.

/*

List下的方法

*/

import java.util.*;

class Demo1

{

public static void main(String[] args)

{

method4();

}

//add(int index,Object obj)

public static void method1(){

List list=new ArrayList();

list.add("hello");

list.add("world");

list.add(1,"ok"); //这个方法的作用是将ok添加到1这个索引的位置

System.out.println(list);

}

//Object get(int index)

public static void method2(){

List list=new ArrayList();

list.add("hello");

list.add("world");

list.add("ok");

//String obj=(String)list.get(1);

//System.out.println(obj);

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

String s=(String)list.get(i);

System.out.println(s);

}

}

//remove

public static void method3(){

List list=new ArrayList();

list.add("hello");

list.add("world");

list.add("ok");

Object obj=list.remove(0);

System.out.println(list);

System.out.println("obj="+obj);

}

//set

public static void method4(){

List list=new ArrayList();

list.add("hello");

list.add("world");

list.add("ok");

Object obj=list.set(1,"小张");

System.out.println(list);

System.out.println("obj="+obj);

}

}

List集合的遍历方式

1.通用方式 Iterator（适用于所有的Collection集合）

通过从Collection继承的iterator方法

2.使用get（只适用于List集合）

因为List集合是有顺序的，我们可以通过索引对其位置上进行控制

3.使用List集合的特有的迭代器械 ListIterator(只适用于List集合)

ListIterator是继承自Iterator，也就是在Iterator中声明的hasNext,next,remove方法它也有。

但是它还提供了特有的方法:add和set

ListIterator比Iterator功能增强

1.Iterator只能从上到下遍历，而ListIterator可以双向遍历

2.Iterator在迭代过程中不能修改,而ListIterator可以add ,set

ArrayList

我们主要研究，ArrayList的实现方式

ArrayList它的实现是使用可变数组

ArrayList类的特点:

1.它的底层实现是使用数组实现。

2.每一次数组会扩充50%

3.它是线程不安全。在单线程中使用。

/*

开发中常用的就是ArrayList集合。

下面用一个列子，来更好的说明ArrayList集合的优势。

需求：根据五种书籍的价格排序，要求使用List集合。

需求：外部输入一个书名，显示对应的作者和价格。

*/

import java.util.*;

class Demo5 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

Book b1 = new Book("绝代双骄","古龙",20);

Book b2 = new Book("聂小凤","古龙",19);

Book b3 = new Book("楚留香","古龙",18);

Book b4 = new Book("多情剑客无情剑","古龙",17);

Book b5 = new Book("昆仑","凤歌",16);

List li = new ArrayList();

li.add(b1);

li.add(b2);

li.add(b3);

li.add(b4);

li.add(b5);

search(li);

System.out.println("请输入要找的书名：");

String st = sc.next();
//外部输入一个书名，根据书名显示作者，价格。

Book boo = new Book();
//创建新对象

boo.name = st;
//新对象调用书名，用外部输入的书名赋给它

int index = li.indexOf(boo);

if (index == -1) {

System.out.println("无这本书");

} else {

System.out.println(li.get(index));

}

}

public static void search(List li) { //用get，遍历List

for (int x=0;x<li.size() ;x++ ) {

System.out.println(li.get(x));

}

}

public static void compare(List li) { //根据价格，给五种书排序

for (int x=0;x<li.size() ;x++ ) {

for (int y=x+1;y<li.size() ;y++ ) {

Book bb1 =((Book)li.get(x));

Book bb2 =((Book)li.get(y));

int p1 = bb1.money;

int p2 = bb1.money;

if (p1>p2) {

li.set(p1,bb2);

li.set(p2,bb1);

}

}

}

}

}

class Book {

String name;

String author;

int money;

Book() {}

Book(String name,String author,int money) { //有参构造

this.name = name;

this.author = author;

this.money = money;

}

public String toString() { //重写toString

StringBuilder ss = new StringBuilder();

ss.append("书名：").append(name).append("\t");

ss.append("作者：").append(author).append("\t");

ss.append("价格：").append(money).append("\t");

return ss.toString();

}

public boolean equals(Object obj) { //判断输入的书名是否符合。

if (this == obj) {

return true;

}

if (obj instanceof Book) {

Book b = (Book)obj;

return this.name.equals(b.name);

}

return false;

}

}

LinkedList

LinkedList的底层实现:双向链表

LinkedList特殊的方法:它可以很方便的操作集合的头尾元素.

它对外提供了 get/remove/add

关于ArrayList与LinkedList集合区别?

ArrayList底层是使用数组实现，在内存中是连续的空间，那么他在做查找时会方法，

但是在做删除/修改时效率比较低.

LinkedList它的底层实现是链表实现，它在做查找时效率比较低。转为每一个元素

头存储的是上一个元素的地址，尾存储的是下一个元素的地址。

但是，它在做删除与修改时效率高。

Vector

Vector是早期应用集合时所使用的一个类.

ArrayList是Vector的替代类.

ArrayList是数组实现，它是每次增加50%,线程不安全.

Vector 是数组实现，它每次拉回100%,线程安全的。

List集合的总结

List 有顺序可重复.

|----ArrayList

它的底层实现是使用数组，每次增长50%,在做查询操作时效率高。是线程不安全。

|----LinkedList

它的底层实现是使用链表，它在做修改与删除时效率高。线程不安全。

Linkedlist对于首尾元素操作比较方便.

|----Vector

它的底层实现是数组，每次增长100%,效率低下，线程安全。

对于List集合的遍历方式

1.Iterator

2.get+索引

3.listIterator

import java.util.*;

class Demo5

{

public static void main(String[] args)

{

method1();

}

//1.使用迭代器

public static void method1(){

List list=new ArrayList();

list.add("张三");

list.add("李四");

list.add("王五");

list.add("赵六");

for(Iterator it=list.iterator();it.hasNext();){

String s=(String)it.next();

System.out.println(s);

}

}

//2.使用get（只适用于List集合）

public static void method2(){

List list=new ArrayList();

list.add("张三");

list.add("李四");

list.add("王五");

list.add("赵六");

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

String s=(String)list.get(i);

System.out.println(s);

}

}

//3.使用ListIterator

public static void method3(){

List list=new ArrayList();

list.add("李四");

list.add("赵六");

list.add("王五");

list.add("孙七");

//在迭代的过程中对元素进行操作

ListIterator lt=list.listIterator();

while(lt.hasNext()){

String s=(String)lt.next();

if("李四".equals(s)){

//lt.add("张三同学"); //ListIterator可以在迭代过程中对元素进行操作

lt.set("张三同学");

}

}

System.out.println(list);

}

}