集合的体系结构：
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<al.size();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<ojt.length;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 当我们看到<E>,就可以使用泛型了
* */
public static void main(String[] args) {
//创建集合对象
Collection<Student> c = new ArrayList<Student>();
// 创建元素对象
Student s = new Student("yuzhentao", 18);
Student s2 = new Student("liewnqi", 19);
// 添加元素对象
c.add(s);
c.add(s2);
// 遍历集合对象
Iterator<Student> 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的子类概述和LinkedListimport 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;
}
}