29.List集合

List集合

1.List集合的功能概述和测试

import java.util.ArrayList;
import java.util.List;

public class Demo6_List {
	/** 
	 A:List集合的特有功能概述
			* void add(int index,E element)
			* E remove(int index)
			* E get(int index)
			* E set(int index,E element)
	 */
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add(1, "e"); //index<=size并且index>=0都不会报异常
		System.out.println(list);
		Object obj = list.remove(2);//通过索引删除元素,将被删除的元素返回
									//删除的时候不会自动装箱				
		System.out.println(obj);
		System.out.println(list);
		System.out.println("------");		
		//Object obj1 = list.get(1);//通过索引，可以实现遍历
		//System.out.println(obj1);
		//通过索引遍历list集合
		for(int i = 0;i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("------");
		//替换集合中的元素
		list.set(0, "ffff");
		System.out.println(list);
		
	}

}

2.通过size()和get()方法结合使用遍历

import java.util.ArrayList;
import java.util.List;

import com.heima.bean.Student;

public class Demo7_List {
	/**
		 * A:案例演示
		* 通过size()和get()方法结合使用遍历。
	 */
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(new Student("张三", 18));//object obj =new Student("张三"，23);父类引用指向子类对象
		list.add(new Student("李四", 18));
		list.add(new Student("王五", 18));
		list.add(new Student("赵六", 18));
		for(int i =0; i < list.size(); i++) {
			//System.out.println(list.get(i));//通过索引获取每个元素
			Student s = (Student)list.get(i);
			System.out.println(s.getName() + "," + s.getAge());
		}
		
	}

}

3.ListIterator

package heima_day15;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Demo9_List {
	/**
		* boolean hasNext()是否有下一个
		* boolean hasPrevious()是否有前一个
		* Object next()返回下一个元素
		* Object previous();返回上一个元素
	 */
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("world");
		list.add("c");
		ListIterator lit = list.listIterator();
		while(lit.hasNext()) {
			System.out.println(lit.next());
		}
		System.out.println("------------");
		while(lit.hasPrevious()) {
			System.out.println(lit.previous());
		}
	}

}

4.Vector

package heima_day15;

import java.util.Enumeration;
import java.util.Vector;

public class Demo10_Vector {

	public static void main(String[] args) {
		Vector v = new Vector();				//创建集合对象,List的子类
		v.addElement("a");
		v.addElement("b");
		v.addElement("c");
		v.addElement("d");
		
		//Vector迭代
		Enumeration en = v.elements();			//获取枚举
		while(en.hasMoreElements()) {			//判断集合中是否有元素
			System.out.println(en.nextElement());//获取集合中的元素
		}
	}

}

5.ArrayList

去除ArrayList中重复字符串元素方式

package heima_day16;

import java.util.ArrayList;
import java.util.Iterator;

public class Demo1_ArrayList {
	// 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
	// 思路：创建新集合方式
	/*
	 * 创建新集合将重复元素去掉
	 * 1.明确返回值类型
	 * 2.明确参数列表ArrayList
	 * 
	 * 分析：
	 * 1.创建新集合
	 * 2.根据老集合获取迭代器
	 * 3.遍历老集合
	 * 4.通过新集合判断是否含有老集合中的元素，如果包含就不添加，如果不包含就添加
	 */
	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add("a");
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("c");		
		list.add("a");
		ArrayList newList =getSingle(list);
		System.out.println(newList);
		
	}
	public static ArrayList getSingle(ArrayList list) {
		ArrayList newList = new ArrayList();//1.创建新集合
		Iterator it = list.iterator();//2.根据传入的集合获取迭代器
		
		while(it.hasNext()) {//3.遍历集合
			Object obj = it.next(); //记录每一个元素
			if(!newList.contains(obj)) {
				newList.add(obj);
				}
			}
		return newList;
		
	}
}

去除ArrayList中重复自定义对象元素

package heima_day16;

import java.util.ArrayList;
import java.util.Iterator;

import heima_day16_bean.Person;

public class Demo2_ArrayList {
	/**
	* A:案例演示
	* 需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
	* B:注意事项
	* 重写equals()方法的
	* contains方法判断是否包含，底层依赖的是equals方法
	* remove也是如此，底层也是依赖equals方法
	 */
	public static void main(String[] args) {
		ArrayList list = new ArrayList();//创建集合对象
		list.add(new Person("张三",23));//每个对象的地址值是不一样的
		list.add(new Person("张三",23));//所以方法是无法区别，需要重写底层的equal方法
		list.add(new Person("张三",23));
		list.add(new Person("李四",24));
		list.add(new Person("李四",24));		
		list.add(new Person("张三",23));
		
		ArrayList newList = getSingle(list);//调用方法
		System.out.println(newList);
		
	}
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static ArrayList getSingle(ArrayList list) {
		ArrayList newList = new ArrayList();//1.创建新集合
		Iterator it = list.iterator();//2.根据传入的集合获取迭代器
		
		while(it.hasNext()) {//3.遍历集合
			Object obj = it.next(); //记录每一个元素
			if(!newList.contains(obj)) {
				newList.add(obj);
				}
			}
		return newList;
		
	}
}

Person类

package heima_day16_bean;



public class Person {

           private String name;

           private int age;

           //<u>alt</u>+shift+s c 空参构造

           public Person() {

                super();

           }

           //<u>alt</u>+shift+s o 有参构造    

           public Person(String name, int age) {

                super();

                this.name = name;

                this.age = age;

           }

           //<u>alt</u>+shift+s r 重写getString方法

           public String getName() {

                return name;

           }

           public void setName(String name) {

                this.name = name;

           }

           public int getAge() {

                return age;

           }

           public void setAge(int age) {

                this.age = age;

           }

           //<u>alt</u>+shift+s s 重写toString方法

           @Override

           public String toString() {

                return "Person [name=" + name + ", age=" + age + 
"]";

           }

           @Override

           public int hashCode() {

                final int prime = 31;

                int result = 1;

                result = prime * result + age;

                result = prime * result + ((name == null) ? 0 : 
name.hashCode());

                return result;

           }

           @Override//重写equals方法

           public boolean equals(Object obj) {

                Person p =(Person)obj;

                return this.name.equals(p.name) && this.age == 
p.age;

           }



}

6.LinkedList的特有功能

import java.util.LinkedList;
public class Demo3_LinkedList {

     /**

           * A:LinkedList类概述

           * B:LinkedList类特有功能

           * public void addFirst(E e)及addLast(E e)

           * public E getFirst()及getLast()

           * public E removeFirst()及public E removeLast()

           * public E get(<u>int</u> index);

      */

     public static void main(String[] args) {

           LinkedList list = new LinkedList();

          list.addFirst("a");

           list.addFirst("b");

           list.addFirst("c");

           list.addFirst("d");;

          list.addLast("e");;

           System.out.println(list);

           System.out.println("--------");

           System.out.println(list.getFirst());

           System.out.println(list.getLast());

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

     }



}

7.用LinkedList模拟栈数据结构的集合并测试

import java.util.LinkedList;
public class Demo4_LinkedList {

     /**

      * A:案例演示

          * 需求：请用LinkedList模拟栈数据结构的集合，并测试

          * 创建一个类将Linked中的方法封装

      */

     public static void main(String[] args) {

           Stack s = new Stack();

           s.in("a");

           s.in("b");

           s.in("c");

           s.in("d");

           while(!s.isEmpty()) {

                System.out.println(s.out());

           }

           /**

            * LinkedList list = new LinkedList();

            

           list.addLast("a");

           list.addLast("b");

           list.addLast("c");

           list.addLast("d");

           

           System.out.println(list.removeLast());

           System.out.println(list.removeLast());

           System.out.println(list.removeLast());

           System.out.println(list.removeLast());

           

           while(!list.isEmpty()) {

                System.out.println(list.removeLast());

           }

           */

     }



}

.List的三个子类的特点

• List的三个子类的特点
          1. ArrayList:
              底层数据结构是数组，查询快，增删慢。
              线程不安全，效率高。
          2. Vector:
              底层数据结构是数组，查询快，增删慢。
              线程安全，效率低。
           Vector相对ArrayList查询慢(线程安全的)
           Vector相对LinkedList增删慢(数组结构)
          3. LinkedList:
              底层数据结构是链表，查询慢，增删快。
              线程不安全，效率高。

• Vector和ArrayList的区别
              Vector是线程安全的,效率低
              ArrayList是线程不安全的,效率高
           共同点:都是数组实现的

• ArrayList和LinkedList的区别
              ArrayList底层是数组结果,查询和修改快
              LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
       共同点:都是线程不安全的

• List有三个儿子，我们到底使用谁呢?
          查询多用ArrayList
          增删多用LinkedList
          如果都多ArrayList