一.List集合的子实现类特点
List集合有三个子实现类:
ArrayList
底层数据结构式数组结构,查询块,增删慢
从内存角度考虑:线程不安全的,不同步的,执行效率高
多线程:synchronized :同步的意思 解决线程安全问题
sychronized(锁对象){ 同步代码
共享数据;
}
解决线程安全问题,通过同步可以解决,但是效率低了...
LinkedList
底层数据结构式链表结构,查询慢,增删块
从内存角度考虑:线程不安全,不同步,执行效率高
Vector
这是一个线程安全的类,
底层数据结构是数组:查询快,增删慢
线程安全的,同步,执行效率低!
二.ArrayList集合
(1)ArrayList是List接口中常用的一个子实现类
(2)遍历功能:
1)一个是Collection的iterator()
2)size()和get(int index)普通for循环
//需求:ArrayList集合存储自定义对象并遍历
public static void main(String[] args) {
//创建集合对象
ArrayList array = new ArrayList();
//创建学生对象
Student s1 = new Student("鲁智深", 30) ;
Student s2 = new Student("武松", 40) ;
Student s3 = new Student("宋江", 50) ;
Student s4 = new Student("杨志", 25) ;
//添加
array.add(s1) ;
array.add(s2) ;
array.add(s3) ;
array.add(s4) ;
//迭代器方式
Iterator it = array.iterator() ;
while(it.hasNext()) {
Student s = (Student)it.next() ;
System.out.println(s.getName()+"---"+s.getAge());
}
System.out.println("--------------------");
//普通for循环
for(int x = 0 ; x <array.size() ; x ++) {
Student s = (Student)array.get(x) ;
System.out.println(s.getName()+"----"+s.getAge());
}
}二.Vector集合
(1)底层是一种可增长对象数组,查询快,增删慢
线程安全,同步,执行效率高
(2)特有功能:
public void addElement(Object obj)——->add(Object obj)
public Enumeration elements():返回此向量的枚举—>相当于:public Iterator iterator()
boolean hasMoreElements() —>boolean hasNext() ;
Object nextElement() —>Object next() ;
public static void main(String[] args) {
//创建集合对象
Vector v = new Vector() ;
//添加元素
v.addElement("hello");
v.addElement("world");
v.addElement("java");
//遍历
//获取Enumeration :向量的枚举
Enumeration en = v.elements() ;
while(en.hasMoreElements()) {
String s = (String)en.nextElement() ;
System.out.println(s);
}
}三.LinkedList集合
(1)底层是一种链表实现,查询慢,增删快
线程不安全的,不同步,执行效率高
(2)特有功能:
添加功能
addFirst(Object e):将指定的元素插入到列表的开头
addLast(object e):将指定的元素添加到列表末尾
获取功能:
getFirst():获取列表第一个元素
getLast():获取列表第二个元素
删除功能
public Object removeFirst()移除并返回此列表的第一个元素。
public Object removeLast()
public static void main(String[] args) {
//创建LinkedList集合对象
LinkedList link = new LinkedList() ;
//添加元素
link.add("hello");
link.add("world");
link.add("java");
System.out.println("link:"+link);
//addFirst(Object e):将指定的元素插入到列表的开头
// link.addFirst("android");
// System.out.println("link:"+link);
// link.addLast("mysql");
// System.out.println(link);
//getFirst():获取列表第一个元素
// System.out.println(link.getFirst());
// System.out.println(link.getLast());
//public Object removeFirst()移除并返回此列表的第一个元素。
System.out.println("removeFirst():"+link.removeFirst());
System.out.println(link);
//public Object removeLast()
System.out.println(link.removeLast());
}
(3)
[需求] 模拟栈结构的特点,先进后出
理解:需要自定义一个类,在这个类中使用LinkedList集合的特有功能进行操作
/**
* 这是自定义的栈集合类
* 在这个MyStack中使用LinkedList的特有功能
* @author Administrator
*
*
*/
public class MyStack {
private LinkedList link ;
/**
*
* 执行MyStack的无参构造实际是构造了个LinkedList对象
*/
public MyStack() {
link = new LinkedList() ;
}
//添加元素
public void add(Object obj) {
link.addFirst(obj);
}
//获取元素
public Object get() {
return link.removeFirst() ;
}
//判断功能
public boolean isEmpty() {
return link.isEmpty();
}
}
/**
* 栈集合的测试类
* @author Administrator
*
*/
public class MyStackDemo {
public static void main(String[] args) {
//创建自定义的MyStack的栈集合的对象
MyStack my = new MyStack() ; //LinkedList list = new LinkedList();
//添加元素
my.add("hello"); //LinkedList ["java","world","hello"]
my.add("world");
my.add("java");
//获取元素
//想办法给MyStack这个类中提供一个判断功能
while(!my.isEmpty()) {
System.out.println(my.get());
}
}
}
四.集合去重
[需求1]给集合中添加重复的元素(字符串类型),将重复的元素从集合去除掉!
思路:
* 1)创建一个旧集合,添加重复元素
* 2)创建一个新集合
* 3)遍历旧集合中的元素获取到每一个元素
* 在旧集合中判断新集合中是否包含旧集合中的元素
* 包含,不搭理
* 不包含,添加到新集合中
* 4)遍历新集合
public static void main(String[] args) {
//创建一个集合
ArrayList list = new ArrayList() ;
//添加元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;
list.add("javaee") ;
list.add("hello") ;
list.add("world") ;
list.add("hello") ;
list.add("javaee") ;
list.add("android") ;
list.add("python") ;
list.add("php") ;
list.add("php") ;
//创建一个新的集合
ArrayList newList = new ArrayList() ;
//遍历旧集合
Iterator it = list.iterator() ;
while(it.hasNext()) {
String s = (String) it.next() ;
//判断新集合中是否包含旧集合中的元素
if(!newList.contains(s)) {
newList.add(s) ;
}
}
//遍历新集合
Iterator it2 = newList.iterator() ;
while(it2.hasNext()) {
String s = (String) it2.next() ;
System.out.println(s);
}
}假设:现在的需求:不允许新建一个集合去完成,怎么办?
/**
* 引入选择排序,
* 用0索引对应的元素依次和后面索引对应的元素进行比较
* 如果前面的元素和后面的元素重复了,把后面的元素干掉
* 依次1索引….
*/
public static void main(String[] args) {
//创建ArrayList集合对象
ArrayList array = new ArrayList() ;
//添加元素
array.add("hello") ;
array.add("world") ;
array.add("java") ;
array.add("javaee") ;
array.add("hello") ;
array.add("world") ;
array.add("hello") ;
array.add("javaee") ;
for(int x = 0 ; x < array.size()-1 ; x ++) {
for(int y = x +1 ; y < array.size() ; y ++) {
//判断,前面的索引对应的元素和后面索引对应的元素进行比较,如果相等就干掉后面重复的
if(array.get(x).equals(array.get(y))) {
array.remove(y) ;
y-- ;
}
}
}
//遍历集合
Iterator it = array.iterator() ;
while(it.hasNext()) {
String s = (String) it.next() ;
System.out.println(s);
}
}
[需求2]使用集合ArrayList存储自定义对象(Student),去除重复的对象(成员变量的值一样,看成一个人)
发现问题:按照存储字符串(新建集合的思想)的形式来去存储自定义对象,发现自定义对象并没有去重,为什么?
* contains方法底层依赖于equals方法
* equals方法默认比较的是地址值,如果想让equals()方法比较他们的内容是否相同,需要重写equals(),也就意味着
存储自定义类,必须重写equals()方法,这样才能比较的是这些对象的内容是否相同
public static void main(String[] args) {
//创建一个ArrayList集合
ArrayList array = new ArrayList() ;
//创建4个学锁对象
Student s1 = new Student("高圆圆", 27);
Student s2 = new Student("文章", 29);
Student s3 = new Student("王力宏", 30);
Student s4 = new Student("高圆圆", 27);
Student s5 = new Student("高圆圆", 29);
array.add(s1) ;
array.add(s2) ;
array.add(s3) ;
array.add(s4) ;
array.add(s5) ;
//创建一个新集合
ArrayList newArray = new ArrayList() ;
//遍历旧集合
Iterator it = array.iterator() ;
while(it.hasNext()) {
Student s = (Student)it.next() ;
//判断,新集合中是否包含
if(!newArray.contains(s)) {
newArray.add(s) ;
}
}
//遍历新集合
Iterator it2 = newArray.iterator() ;
while(it2.hasNext()) {
Student s= (Student)it2.next();
System.out.println(s.getName()+"---"+s.getAge());
}
}