java collection 使用_JAVA Collection在java中的使用

集合的体系结构：

import java.util.ArrayList;

/*

* ArrayList

* 集合的体系结构

* 由于不同的数据结构(数据的组织 存储方式)，所以java为我们提供了不同的集合

* 但是不同的集合他们的功能都是相似的，不断地向上提取，将他们的共性提取出来，这就是集合体系结构形成的原因

* 体系结构

* 怎么学习？ 从最顶层开始学习，因为最顶层包含了所有的共性

* 怎么使用？ 从最底层开始使用，因为最底层就是i具体的实现

* collcetion

* list

* ArrayList

* */

public class CollectionDemo{

public static void main(String []args)

{

//创建集合对象

ArrayList al = new ArrayList();

//添加元素

al.add("hello");

al.add("world");

al.add("java");

//遍历集合

for(int x = 0;x

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

}

}

Collection中的常用功能：

import java.util.ArrayList;

import java.util.Collection;

/*

* Collection 是一个接口

* boolean add(E e)

确保此集合包含指定的元素(可选操作)。

void clear()

从此集合中删除所有元素(可选操作)。

boolean contains(Object o)

如果此集合包含指定的元素，则返回 true 。

boolean isEmpty()

如果此集合不包含元素，则返回 true 。

boolean remove(Object o)

从该集合中删除指定元素的单个实例(如果存在)(可选操作)。

int size()

返回此集合中的元素数。

Object[] toArray()

返回一个包含此集合中所有元素的数组。

* */

public class Collection_Common {

public static void main(String []args) {

// 创建集合对象

// Collection c = new Collection();

Collection c = new ArrayList();//多态

System.out.println(c.add("hello"));

System.out.println(c.add("world"));

System.out.println(c);

}

}

迭代器的概述和测试

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

public class IteratorDemo{

/*

* 集合的遍历方式

* 1 toArray() 将集合转换成数组，然后遍历数组

* 2 iterator() 可以返回一个迭代器对象 我们可以通过迭代器对象来迭代集合

* Iterator ：可以用于遍历

* next()：返回下一个元素

* 注意： Exception in thread "main" java.util.NoSuchElementException

* 使用next方法获取下一个元素 如果没有就会出现NoSuchElementException

* 这时我们可以使用 hasNext()方法来判断是否还有下一个元素

*

* */

public static void main(String []args)

{

// 创建集合对象

Collection c = new ArrayList();

// 添加元素

c.add("hello");

c.add("world" );

// 获取数组

Object ojt[] = c.toArray();

// 遍历数组

for(int i=0;i

System.out.println(ojt[i]);

// 获取迭代器对象

Iterator it = c.iterator();

// Object next() :返回下一个元素

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

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

while(it.hasNext())

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

System.out .println("没有元素了" );

}

}

并发修改异常：

import java.util.ArrayList;

import java.util.Collection;

import java.util.ListIterator;

// 处理并发修改异常

public class IteratorDemo3 {

public static void main(String []args){

// 创建集合对象

Collection c = new ArrayList();

// 添加元素

c.add("hello");

c.add("java");

// 判断集合中是否含有元素 java

if(c.contains("java"))

c.add("android");

System.out.println(c);

// 获取迭代器对象 通过遍历的放式来获取集合中的每一个元素 然后一个一个去比较

// 这样是不行的 原因在于迭代器是依赖于集合的 相当于集合的一个副本 当迭代器进行操作时 如果发现和集合不一样 就会抛出异常

// 解决： 1 别使用迭代器

// 2 在使用迭代器进行遍历的时候使用迭代器进行修改

ListIterator lit = ((ArrayList) c).listIterator();

while(lit.hasNext()){

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

if (s.equals("java"))

{

lit.add("android");

}

}

System.out.println(c);

}

}

泛型的概述和体现：

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

public class GenericDemo {

/* 使用集合存储自定义对象并遍历

* 由于集合可以存储任意类型的对象，当我们存储了不同类型的对象，就有可能在转换的时候出现类型转换异常

* java为了解决这个问题 为我们提供了一种泛型

* 泛型：是一种广泛的类型 把明确数据类型的任务提前到了编译时期，借鉴了数组的特点

* 泛型 好处：

* 避免了类型转换的问题

* 什么时候可以使用泛型

* 问API 当我们看到,就可以使用泛型了

* */

public static void main(String[] args) {

//创建集合对象

Collection c = new ArrayList();

// 创建元素对象

Student s = new Student("yuzhentao", 18);

Student s2 = new Student("liewnqi", 19);

// 添加元素对象

c.add(s);

c.add(s2);

// 遍历集合对象

Iterator it = c.iterator();

while(it.hasNext())

{

Student stu = it.next();

System.out.println(stu.name);

}

}

}

class Student {

String name;

int age;

public Student(String name,int age)

{

this.name = name;

this.age = age;

}

}

for_each语句：

import java.util.ArrayList;

import java.util.Collection;

public class ForEachDema {

/*

* foreach:增强for循环 一般用于遍历集合或者数组

* 格式

* for(元素的类型变量：集合或者数组对象)

* {

* 可以直接使用变量

* }

* 在 增强for循环中也能修改集合 否则会出现并发修改异常

* 因为增强for的底层是迭代器

* */

public static void main(String[] args) {

// 创建集合对象

Collection c = new ArrayList();

//添加元素

c.add("hello");

c.add("world");

//使用for循环遍历集合

for(Object obj:c)

{

System.out.println(obj); // 这里需要注意一个问题 这里的集合c 你并没有使用泛型来确定到底是哪一种类型 所以你要使用Object

// 因为集合里面可以存储不同类型的元素 你没有确定类型 所以只能用Object

}

}

}

List的特点和概述：

import java.util.ArrayList;

import java.util.List;

/* List :有序的(存储和读取的顺序是一致的)

有整数索引

允许里面有重复元素

*

* List的特有红能：

*void add(int index, E element)

将指定的元素插入此列表中的指定位置(可选操作)。

E get(int index)

返回此列表中指定位置的元素。

E remove(int index)

删除该列表中指定位置的元素(可选操作)。

E set(int index, E element)

用指定的元素(可选操作)替换此列表中指定位置的元素。

增删改查

* */

public class ListDemo {

public static void main(String[] args) {

// 创建列表对象

List list = new ArrayList();

list.add(0,"hello");

list.add(1,"world");

list.add(2,"java");

list.remove(2);

System.out.println(list.set(0,"yu"));

System.out.println(list.get(0));

}

}

List的子类概述和LinkedList

import java.util.LinkedList;

/*

* List 的常用子类：

* ArrayList

* 底层是数组结构，查询快，增删慢

* Linkedlist

* 底层结构结构是链表 查询满 增删快

* 如何使用不同的集合？

* 如果查询多，增删少，就使用ArrayList

* 如果查询少，增删多，就使用LinkedList

* 如果你不知道使用什么合适 则使用ArrayList

* Linkedlist 特有功能：(增删查)

* void addFirst(E e)

在该列表开头插入指定的元素。

void addLast(E e)

将指定的元素追加到此列表的末尾。

E getFirst()

返回此列表中的第一个元素。

E getLast()

返回此列表中的最后一个元素。

E removeFirst()

从此列表中删除并返回第一个元素。

E removeLast()

从此列表中删除并返回最后一个元素。

*

*

**/

public class LinkedListDemo {

public static void main(String[] args) {

LinkedList list = new LinkedList();

list.add("java");

list.add("hello");

list.addFirst("hello");

list.addLast("android");

System.out.println(list);

}

}

查找元素索引及判断元素是否存在案例：

import java.util.ArrayList;

import java.util.List;

/*

* */

public class ListTest {

public static void main(String[] args) {

List list = new ArrayList();

list.add("hello");

list.add("world");

list.add("java");

int index = index(list,"java");

System.out.println(index);

boolean flag = contains(list,"php" );

System.out.println(flag);

}

public static int index(List list,Object other)

{

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

// 获取列表中的元素

Object obj = list.get(i);

// 使用列表中的元素和指定的元素进行比较

if (obj.equals(other)) {

return i;

}

}

// 查找不成功

return -1;

}

public static boolean contains(List list,Object other)

{

//获取指定元素在指定列表中的元素位置

int index = index(list ,other);

if (index>=0)

return true;

else

return false;

}

}