Java基础-List实现类&泛型

数据结构：

了解常用的数据结构：

栈、队列、堆、数据、链表、红黑树（二叉树）、图、哈希结构

    栈的特点：先进后出

队列的特点：先进先出

栈和队列的示例图：

数组数据结构和链表数据结构

数组数据结构的概念和特点:

概念:存储同一种数据类型元素的容器

特点:存在引用,可以按照索引查找

优点:查询快

缺点:增删慢

链表数据结构的概念和特点:

概念:把一些节点用链子连接起来的数据结构

优点:增删快

缺点:查询慢

链表结构和数组结构的示意图

List接口的三个实现子类的特点:

A：ArrayList类的特点：

底层是数组结构，查询快，增删慢；线程不安全，效率高

B：Vector类的特点：

底层是数组机构，查询快，增删慢；线程安全，效率低

C：LinkedList类的特点：

底层是链表结构，增删快，查询慢；线程不安全，效率低

例题：
                               一个字符串集合ArrayList中含有如下元素：hello, world, java, 
hello, java, php, android，world。要求编写程序，获得一个没有重复元素的新集合。
          

思路：

1 创建两个集合对象一个老集合,一个新集合
2 给老集合中添加元素
3 遍历老集合得到老集合中的每一个数据
4 再得到老集合中的数据后用新集合进行判断,判断集合中是否包含数据,
如果不包含,则把数据添加到新集合当中,如果包含不添加

代码：

public class Test1 {public static void main(String[] args) {// 创建一个集合,添加上面的元素Collection c = new ArrayList();// 创建一个新的集合Collection c1 = new ArrayList();// 添加元素c.add("hello");c.add("world");c.add("java");c.add("hello");c.add(".net");c.add("java");c.add("php");c.add("ios");c.add("java");c.add("android");c.add("world");System.out.println("c: " + c);System.out.println("c1: " + c1);// 遍历集合// 获取迭代器Iterator it = c.iterator();// 遍历while (it.hasNext()) {String s = (String)it.next();if(!(c1.contains(s))){c1.add(s);}//System.out.println(c1.contains(it.next()));// if(!(c1.contains(it.next()))){// c1.add(it.next());}System.out.println("c1:" + c1);}}

结果：

例题：

ArrayList存储自定义对象去重复

代码：

import java.util.ArrayList;import java.util.Iterator;public class Test2 {public static void main(String[] args) {// 创建一个集合ArrayList<Student> array = new ArrayList<>();// 创建第二个集合ArrayList<Student> array2 = new ArrayList<>();// 创建Student对象Student s1 = new Student("小苍", 20);Student s2 = new Student("苍井", 20);Student s3 = new Student("小龙", 21);Student s4 = new Student("小龙", 21);Student s5 = new Student("苍井", 21);Student s6 = new Student("小泽", 18);// 向集合array添加Student对象array.add(s1);array.add(s2);array.add(s3);array.add(s4);array.add(s5);array.add(s6);// 遍历array集合Iterator it = array.iterator();while (it.hasNext()) {Student s = (Student) it.next();if (!(array2.contains(s))) {array2.add(s);}}/* *  输出去重后的集合,由于集合arrays中存储的是Student对象的引用 *  因此,我们需要遍历每一个元素,然后输入每一个对象中对应的属性 */System.out.println("去重后的集合: " + array2);for(int x=0;x<array2.size();x++){Student s = array2.get(x);System.out.println(s.getName() + "---" + s.getAge());}}}

结果：

重点学习ArrayList

ArrayList存储字符串并遍历

代码如下：

import java.util.ArrayList;import java.util.Iterator;/* * ArrayList存储字符串并遍历 *  * 作业：用ArrayList存储自定义对象并遍历。 */public class ArrayListDemo {public static void main(String[] args) {// 创建集合对象ArrayList array = new ArrayList();// 创建并添加元素array.add("hello");array.add("world");array.add("java");// 遍历集合Iterator it = array.iterator();while (it.hasNext()) {String s = (String) it.next();System.out.println(s);}System.out.println("-----------");// for (int x = 0; x < array.size(); x++) {// String s = (String) array.get(x);// System.out.println(s);// }// 开发中，我会按照如下方式写,请问为什么?//上面那种方式，每次都会调用size()方法,效率低。//下面这种方式，我们只调用一次。效率较高。int length = array.size();for (int x = 0; x < length; x++) {String s = (String) array.get(x);System.out.println(s);}}}

ArrayList中存储自定义对象，然后遍历

代码：

import java.util.ArrayList;import java.util.Iterator;/* * ArrayList存储自定义对象并遍历 */public class ArrayListDemo2 {public static void main(String[] args) {ArrayList array = new ArrayList();Student s1 = new Student("乔峰", 40);Student s2 = new Student("虚竹", 36);Student s3 = new Student("段誉", 28);array.add(s1);array.add(s2);array.add(s3);Iterator it = array.iterator();while (it.hasNext()) {Student s = (Student) it.next();System.out.println(s.getName() + "***" + s.getAge());}System.out.println("-------------");for (int x = 0; x < array.size(); x++) {Student s = (Student) array.get(x);System.out.println(s.getName() + "***" + s.getAge());}}}

结果：

例题：

* ArrayList如果存储的是学生，那么，怎么去除重复元素呢?
  * 问题：如何知道学生是重复的。
  * 需求：如果学生的姓名和年龄相同，我就认为是同一个学生。即重复值。
 * 
 * 通过简单分析，我们估计是判断那里出问题了。
 * 怎么办呢?
 * 看判断的方法。
 * 而我们又知道，判断的方法是API提供的。不是自己的写的。
  * 看源码，看底层到底怎么实现的。
  * 通过看源码，我们发现，底层依赖的是equals()。
 * 由于学生类中，我们并没有equals()方法，所以，默认用的是Object的方法。
  * 而Object类的方法，默认比较的是地址值。
  * 由于学生对象都是new出来的，地址值肯定不一样，所以从这个角度考虑结论是正确的。
  * 但是不符合我们的需求。
  * 肿么办?
 * 重写equals()，让他按照我们的需要来比较。


代码如下：

public class ArrayListTest3 {public static void main(String[] args) {ArrayList array = new ArrayList();Student s1 = new Student("郑成功", 40);Student s2 = new Student("戚继光", 50);Student s3 = new Student("戚继光", 50);Student s4 = new Student("岳飞", 36);Student s5 = new Student("岳飞", 40);Student s6 = new Student("林则徐", 30);array.add(s1);array.add(s2);array.add(s3);array.add(s4);array.add(s5);array.add(s6);// 创建新集合ArrayList array2 = new ArrayList();// 遍历旧集合，获取到每一个元素Iterator it = array.iterator();while (it.hasNext()) {Student s = (Student) it.next();// 在新集合中判断，看是否存在这个元素if (!array2.contains(s)) {// 如果s不再array2中存在，就添加array2.add(s);}}// array2就是没有重复元素的集合。// 遍历array2for (int x = 0; x < array2.size(); x++) {Student s = (Student) array2.get(x);System.out.println(s.getName() + "***" + s.getAge());}}}

Student类代码：

public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}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;}@Overridepublic boolean equals(Object obj) {// 提高效率if (this == obj) {return true;}// 提高健壮性if (!(obj instanceof Student)) {return false;}// 向下转换Student s = (Student) obj;return this.name.equals(s.name) && this.age == s.age;}}

Vector的特有功能：

* Vector的特有功能：
 * A:添加功能 升级后方法
 * public void addElement(Object obj) -- add(Object obj)
  * B:获取功能
  * public Object elementAt(int index)--get(int index)
 * public Enumeration elements()--Iterator
  * boolean hasMoreElements()--hasNext()
  * Object nextElement()--  next()
  * C:长度功能
  * public int size()
 * 
  * JDK版本升级：
  * A:安全
  * B:效率
  * C:简化书写

Vector类特有方法代码；

public class VectorDemo {public static void main(String[] args) {// 创建集合对象Vector v = new Vector();// 添加元素v.addElement("hello");v.addElement("world");v.addElement("java");// 遍历// System.out.println(v.elementAt(0));// System.out.println(v.elementAt(1));// System.out.println(v.elementAt(2));for (int x = 0; x < v.size(); x++) {String s = (String) v.elementAt(x);System.out.println(s);}System.out.println("----------------");//public Enumeration elements()Enumeration en = v.elements();while(en.hasMoreElements()){String s = (String)en.nextElement();System.out.println(s);}}}

结果

LinkedList的特有方法：

A：添加功能 
 * void addFirst(Object e) 
 * void addLast(Object e) 
 * B:获取功能
 * Object getFirst() 
 * Object getLast() 
 * C:删除功能
 * Object removeFirst()
 * Object removeLast()

代码：

public class LinkedListDemo {public static void main(String[] args) {LinkedList link = new LinkedList();link.add("hello");link.add("world");link.add("java");// 添加功能// link.addFirst("EE");// link.addLast("ME");// 获取功能// System.out.println("getFirst:"+link.getFirst());// System.out.println("getLast:"+link.getLast());// 删除功能System.out.println("removeFirst:" + link.removeFirst());System.out.println("removeLast:" + link.removeLast());System.out.println("link:" + link);}}

结果：

分析结果可知，LinkedList方法中的remove功能，影响结合中的元素

面试题：

通过LinkedList模拟栈数据结构
  要模拟的内容的特点：
  先进后出。

  通过LinkedList模拟栈数据结构: 它的意思是说，你有一个LinkedList可以用，但是，你需要自己定义一个栈集合。
对外提供获取和添加功能。

实现栈结构代码：

import java.util.LinkedList;/* * 自定义栈集合。 */public class MyStack {private LinkedList link;public MyStack() {link = new LinkedList();}public void add(Object obj) {link.addFirst(obj);}public Object get(int index) {return link.get(index);}public int size() {return link.size();}}

使用自定义栈结构代码；

public class LinkedListTest {public static void main(String[] args) {// 创建集合对象MyStack ms = new MyStack();// 创建并添加元素ms.add("hello");ms.add("world");ms.add("java");// 获取// System.out.println(ms.get(0));// System.out.println(ms.get(1));// System.out.println(ms.get(2));// System.out.println(ms.get(3));for (int x = 0; x < ms.size(); x++) {String s = (String) ms.get(x);System.out.println(s);}}}

结果：

分析结果：实现了栈的特点：先进后出

泛型：

  ClassCastException：类型转换问题
  
  泛型：任意的类型。是一种把明确数据类型的工作放在了创建对象或者调用方法 时候进行的特殊的类型。
  
  泛型的格式：
  <数据类型>
  
  为什么会有泛型? 就是为了解决黄线和类型转换问题。
  怎么解决呢?
  就是模仿数组解决的，在定义集合的时候，告诉集合，你只能存储什么类型的元 素。
  怎么告诉呢，通过泛型。
  
  泛型的好处：
  A:解决黄色警告线问题。
  B:把运行期间的类型转换异常提前到了编译期间。
  C:优化程序设计。
  
  泛型在哪些地方用啊?
  别问我，问API。如果类或者接口后面有<>，那么这就是泛型的体现。它就是要你在使用的时候明确类型的。
  泛型一般就在集合中用。

代码：

<span style="font-size:24px;">public class ArrayListDemo {public static void main(String[] args) {// 用ArrayList存储字符串并遍历ArrayList<String> array = new ArrayList<String>();array.add("hello");array.add("world");array.add("java");// array.add(10);// 等价于array.add(new Integer(10));Iterator<String> it = array.iterator();while (it.hasNext()) {String s = (String) it.next();System.out.println(s);// System.out.println(it.next());}// 数组在定义的时候，就明确告诉你了，我们的元素是某种固定的类型。不能是其他类型。// String[] strArray = new String[3];// strArray[0] = "hello";// strArray[1] = "world";// strArray[2] = 0;}}</span>

增强for循环

  * 格式：
  * for(数组或者Collection集合中元素类型 变量名 : 数组或者Collection 集合对象)
  * {
  * 使用变量名即可。
  * }
 * 
  * 作用：简化数组和Collection集合的变量。
  * 注意：增强for是用来替代迭代器的。不能再用增强for的时候，用集合对象对集合进行改变。

代码：

public class ForDemo {public static void main(String[] args) {// 整型数组int[] arr = { 1, 2, 3, 4, 5 };// 普通forfor (int x = 0; x < arr.length; x++) {System.out.println(arr[x]);}System.out.println("--------------");// 增强forfor (int x : arr) {System.out.println(x);}System.out.println("--------------");// 字符串数组String[] strArray = { "hello", "world", "java" };// 增强forfor (String str : strArray) {System.out.println(str);}System.out.println("--------------");// 集合ArrayList<String> array = new ArrayList<String>();array.add("hello");array.add("world");array.add("java");for (String str : array) {System.out.println(str);}System.out.println("--------------");// 增强for和迭代器我们一般只选一种。// 增强for是来替代迭代器的。// ArrayList<String> array2 = new ArrayList<String>();// array2.add("hello");// array2.add("world");// array2.add("java");// ConcurrentModificationExceptionArrayList<String> array2 = null;// NullPointerExceptionfor (String str : array2) {if (str.equals("world")) {array2.add("EE");}}}}

结果