集合
集合的体系结构
- 由于不同的数据结构(数据的组织方式),所以Java为我们提供了不同的集合
- 不同的集合的功能是相似的,不断的向上提取,将共性抽取出来,这就是体系结构形成的原因
体系结构:
- 最顶层,包含了所有的共性
- 使用最底层,具体的实现
例如:ArrayList----List-----Collection
package com.it01;
import java.util.ArrayList;
public class CollectionDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
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的常见功能:
- boolean add(E e)
- void clear()
- boolean contains(Object o)
- boolean isEmpty()
- boolean remove(Object o)
- int size()
- Object[] toArray()
package com.it01;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Collection c = new ArrayList();// 多态,父类引用指向子类对象
// boolean add(E e)
System.out.println(c.add("hello"));
System.out.println(c.add("world"));
System.out.println(c);
//void clear()清空集合
c.clear();
System.out.println(c);
//boolean contains(Object o)
c.add("hello");
c.add("world");
System.out.println(c.contains("hello"));
//boolean isEmpty()
System.out.println(c.isEmpty());
//boolean remove(Object o)
System.out.println(c.remove("hello"));
System.out.println(c);
//int size()
System.out.println(c.size());
//Object[] toArray() ,将集合变成Object类型数组
Object[] ob = c.toArray();
System.out.println(ob[0]);
}
}
集合的遍历方式
- 1-toArray,可以把集合变成数组,遍历数组
- 2-Iterator返回一个迭代器对象,我们可以通过迭代器对象来迭代集合
Iterator:可以用于遍历集合
Iterator iterator()
- E next() :返回下一个元素
- boolean hasNext() :如果迭代具有更多元素,则返回 true
注意:next()获取下一个元素,如果没有元素可以获取,则出现异常
package com.it02;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
method1();
method2();
}
private static void method2() {
Collection c = new ArrayList();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
//获取迭代器对象
Iterator it = c.iterator();
//E next() :返回下一个元素
while(it.hasNext()) {
System.out.println(it.next());
}
}
private static void method1() {
//创建集合
Collection c = new ArrayList();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
//获取数组
Object[] ob = c.toArray();
//遍历数组
for(int x=0;x<ob.length;x++) {
System.out.println(ob[x]);
}
}
}
泛型
由于集合可以存储任意类型的对象,当我们存储了不同类型的对象,就有可能在转换的时候出现类型转换的异常,所以提供了泛型机制
泛型:把明确数据类型的工作提前到了编译时期,借鉴了数组的特点
泛型的好处:
- 避免了类型转换的问题
- 可以减少黄色警告
- 可以简化代码的书写
使用:
- API:当我们看到时可以使用
package com.it03;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* 使用集合存储自定义对象并遍历
*/
public class GenericDemo {
public static void main(String[] args) {
//创建集合对象
Collection<Student> c = new ArrayList<Student>();
//创建元素对象
Student s1 = new Student("wangwu", 29);
Student s2 = new Student("zhangsan", 30);
//添加元素对象
c.add(s1);
c.add(s2);
//遍历集合对象
Iterator<Student> it=c.iterator();
while(it.hasNext()) {
Student str =it.next();
System.out.println(str.name+"----"+str.age);
}
}
}
class Student{
String name;
int age;
public Student(String name, int age) {
//super();
this.name = name;
this.age = age;
}
}
foreach:增强for循环,一般用于遍历集合或者数组
package com.it04;
import java.util.ArrayList;
import java.util.Collection;
/*
* foreach:增强for循环,一般用于遍历集合或者数组
* 格式:
* for(元素的类型 变量:集合或者数组对象){
* 可以直接使用变量
*
* }
*
* 注意:在增强for循环中不能修改集合,否则会出现并发修改异常
*
*
*/
public class ForEachDemo {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
//增强for循环,遍历集合
for(String str:c) {
System.out.println(str.toUpperCase());
}
}
}
常见的几种数据结构
List集合
List:
- 有序的(存储和读取的顺序是一致的)
- 有整数索引
- 允许重复
几种常见的方法
- void add(int index, E element) :将指定的元素插入此列表中的指定位置(可选操作)
- E get(int index) :返回此列表中指定位置的元素
- E remove(int index) :删除该列表中指定位置的元素(可选操作)。
- E set(int index, E element) :用指定的元素(可选操作)替换此列表中指定位置的元素
package com.it05;
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
//创建列表对象
List l = new ArrayList();
//添加void add(int index, E element)
l.add(0,"hello");
l.add(0,"world");
l.add(0,"java");
//获取E get(int index) :返回此列表中指定位置的元素
System.out.println(l.get(0));
//E remove(int index) :删除该列表中指定位置的元素(可选操作)
System.out.println(l.remove(0));
//E set(int index, E element) :用指定的元素(可选操作)替换此列表中指定位置的元素
System.out.println(l.set(0, "java"));
System.out.println(l);
}
}
List的子类
常见子类:
- ArrayList-底层时数组结构,查询快,增删慢
- LinkedList-底层结构是链表,查询慢,增删快
如何使用集合
-
如果查询多,增删少,使用ArrayList
-
如果查询少,增删多,使用LinkedList
LinkedList的特有方法
- void addFirst(E e):在该列表开头插入指定的元素
- void addLast(E e):将指定的元素追加到此列表的末尾
- E getFirst()
- E getLast()
- E removeFirst()
- E removeLast()
package com.it06;
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.add("hello");
list.add("world");
//void addFirst(E e):在该列表开头插入指定的元素
list.addFirst("java");
//void addLast(E e):将指定的元素追加到此列表的末尾
list.addLast("android");
System.out.println(list);
//E getFirst()
System.out.println(list.getFirst());
//E getLast()
System.out.println(list.getLast());
//E removeFirst()
System.out.println(list.removeFirst());
//E removeLast()
System.out.println(list.removeLast());
System.out.println(list);
}
}
List测试
package com.it07;
import java.util.ArrayList;
import java.util.List;
/*
* 需求:定义一个方法,返回指定列表中指定元素的索引位置
* 判断元素是否存在
*/
public class ListTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
List list = new ArrayList();
list.add("hello");
list.add("java");
list.add("android");
int index = getIndex(list,"java");
System.out.println(index);
}
public static int getIndex(List list,Object other) {
for (int x=0;x<list.size();x++) {
//获取元素
Object obj = list.get(x);
if(obj.equals(other)) {
return x;
}
}
//查找不到
return -1;
}
public static boolean contains(List list,Object other) {
int index = getIndex(list, other);
if(index>-1) {
return true;
}
return false;
}
}