集合——list下的子类以及泛型
ArrayList特点:
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
ArrayList的使用。
存储字符串并遍历
demo： |
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); } } } |
Vector的特有功能：
1：添加功能
public void addElement(Object obj) -- add()
2：获取功能
public Object elementAt(int index) -- get()
public Enumeration elements() -- Iterator iterator()
boolean hasMoreElements() hasNext()
Object nextElement() next()
JDK升级的原因：
A:安全
B:效率
C:简化书写
demo： |
public class VectorDemo { public static void main(String[] args) { // 创建集合对象 Vector v = new Vector();
// 添加功能 v.addElement("hello"); v.addElement("world"); v.addElement("java");
// 遍历 for (int x = 0; x < v.size(); x++) { String s = (String) v.elementAt(x); System.out.println(s); }
System.out.println("------------------");
Enumeration en = v.elements(); // 返回的是实现类的对象 while (en.hasMoreElements()) { String s = (String) en.nextElement(); System.out.println(s); } } } |
LinkedList的特有功能：
A:添加功能
public void addFirst(Object e)
public void addLast(Object e)
B:获取功能
public Object getFirst()
public Obejct getLast()
C:删除功能
public Object removeFirst()
public Object removeLast()
demo： |
public class LinkedListDemo { public static void main(String[] args) { // 创建集合对象 LinkedList link = new LinkedList();
// 添加元素 link.add("hello"); link.add("world"); link.add("java");
// public void addFirst(Object e) // link.addFirst("javaee"); // public void addLast(Object e) // link.addLast("android");
// public Object getFirst() // System.out.println("getFirst:" + link.getFirst()); // public Obejct getLast() // System.out.println("getLast:" + link.getLast());
// public Object removeFirst() System.out.println("removeFirst:" + link.removeFirst()); // public Object removeLast() System.out.println("removeLast:" + link.removeLast());
// 输出对象名 System.out.println("link:" + link); } } |
ArrayList去除集合中字符串的重复值(字符串的内容相同)
demo： 分析： A:创建集合对象 B:添加多个字符串元素(包含内容相同的) C:创建新集合 D:遍历旧集合,获取得到每一个元素 E:拿这个元素到新集合去找，看有没有 有：不搭理它 没有：就添加到新集合 F:遍历新集合
|
public class ArrayListDemo { public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList();
// 添加多个字符串元素(包含内容相同的) array.add("hello"); array.add("world"); array.add("java"); array.add("world"); array.add("java"); array.add("world"); array.add("world"); array.add("world"); array.add("world"); array.add("java"); array.add("world");
// 创建新集合 ArrayList newArray = new ArrayList();
// 遍历旧集合,获取得到每一个元素 Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next();
// 拿这个元素到新集合去找，看有没有 if (!newArray.contains(s)) { newArray.add(s); } }
// 遍历新集合 for (int x = 0; x < newArray.size(); x++) { String s = (String) newArray.get(x); System.out.println(s); } } } |
demo： 不创建新的list解决上边问题 |
public class ArrayListDemo2 { public static void main(String[] args) { // 创建集合对象 ArrayList array = new ArrayList();
// 添加多个字符串元素(包含内容相同的) array.add("hello"); array.add("world"); array.add("java"); array.add("world"); array.add("java"); array.add("world"); array.add("world"); array.add("world"); array.add("world"); array.add("java"); array.add("world");
// 由选择排序思想引入，我们就可以通过这种思想做这个题目 // 拿0索引的依次和后面的比较，有就把后的干掉 // 同理，拿1索引... 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); } } } |
用LinkedList模拟栈数据结构的集合，并测试
demo： 工具类 |
public class MyStack { private LinkedList link;
public MyStack() { link = new LinkedList(); }
public void add(Object obj) { link.addFirst(obj); }
public Object get() { // return link.getFirst(); return link.removeFirst(); }
public boolean isEmpty() { return link.isEmpty(); } } |
demo： 测试类 |
public class MyStackDemo { public static void main(String[] args) { // 创建集合对象 MyStack ms = new MyStack();
// 添加元素 ms.add("hello"); ms.add("world"); ms.add("java");
// System.out.println(ms.get()); // System.out.println(ms.get()); // System.out.println(ms.get()); // NoSuchElementException // System.out.println(ms.get());
while(!ms.isEmpty()){ System.out.println(ms.get()); } } } |
泛型：
是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递。
格式：
<数据类型>
此处的数据类型只能是引用类型。
好处：
A:把运行时期的问题提前到了编译期间
B:避免了强制类型转换
C:优化了程序设计，解决了黄色警告线
Demo: 存储自定义对象并遍历。 A:创建学生类 B:创建集合对象 C:创建元素对象 D:把元素添加到集合 E:遍历集合 |
public class ArrayListDemo2 { public static void main(String[] args) { // 创建集合对象 // JDK7的新特性：泛型推断。 // ArrayList<Student> array = new ArrayList<>(); // 但是我不建议这样使用。 ArrayList<Student> array = new ArrayList<Student>();
// 创建元素对象 Student s1 = new Student("曹操", 40); // 后知后觉 Student s2 = new Student("蒋干", 30); // 不知不觉 Student s3 = new Student("诸葛亮", 26);// 先知先觉
// 添加元素 array.add(s1); array.add(s2); array.add(s3);
// 遍历 Iterator<Student> it = array.iterator(); while (it.hasNext()) { Student s = it.next(); System.out.println(s.getName() + "---" + s.getAge()); } System.out.println("------------------");
for (int x = 0; x < array.size(); x++) { Student s = array.get(x); System.out.println(s.getName() + "---" + s.getAge()); } } } |
我们可以把泛型定义在类上
demo： 把泛型定义在类上 |
public class ObjectTool<T> { private T obj;
public T getObj() { return obj; }
public void setObj(T obj) { this.obj = obj; } } |
demo： 将泛型定义在类上的测试 |
public class ObjectToolDemo { public static void main(String[] args) { // ObjectTool ot = new ObjectTool(); // // ot.setObj(new String("风清扬")); // String s = (String) ot.getObj(); // System.out.println("姓名是：" + s); // // ot.setObj(new Integer(30)); // Integer i = (Integer) ot.getObj(); // System.out.println("年龄是：" + i);
// ot.setObj(new String("林青霞")); // // ClassCastException // Integer ii = (Integer) ot.getObj(); // System.out.println("姓名是：" + ii);
System.out.println("-------------");
ObjectTool<String> ot = new ObjectTool<String>(); // ot.setObj(new Integer(27)); //这个时候编译期间就过不去 ot.setObj(new String("林青霞")); String s = ot.getObj(); System.out.println("姓名是：" + s);
ObjectTool<Integer> ot2 = new ObjectTool<Integer>(); // ot2.setObj(new String("风清扬"));//这个时候编译期间就过不去 ot2.setObj(new Integer(27)); Integer i = ot2.getObj(); System.out.println("年龄是：" + i); } } |
泛型方法：把泛型定义在方法上：
Demo: 把泛型定义在方法上： |
public class ObjectTool { public <T> void show(T t) { System.out.println(t); } } |
Demo: 泛型定义在方法上的测试 |
public class ObjectToolDemo { public static void main(String[] args) { // 定义泛型方法后 ObjectTool ot = new ObjectTool(); ot.show("hello"); ot.show(100); ot.show(true); } } |
泛型定义在接口上：
demo： 泛型接口：把泛型定义在接口上 |
public interface Inter<T> { public abstract void show(T t); } |
Demo: |
//实现类在实现接口的时候 //第一种情况：已经知道该是什么类型的了
//public class InterImpl implements Inter<String> { // // @Override // public void show(String t) { // System.out.println(t); // } // }
//第二种情况：还不知道是什么类型的 public class InterImpl<T> implements Inter<T> {
@Override public void show(T t) { System.out.println(t); } } |
Demo: 测试 |
package cn.itcast_06;
public class InterDemo { public static void main(String[] args) { // 第一种情况的测试 // Inter<String> i = new InterImpl(); // i.show("hello");
// // 第二种情况的测试 Inter<String> i = new InterImpl<String>(); i.show("hello");
Inter<Integer> ii = new InterImpl<Integer>(); ii.show(100); } } |
泛型的通配符：
泛型高级(通配符)
?:任意类型，如果没有明确，那么就是Object以及任意的Java类了
? extends E:向下限定，E及其子类
? super E:向上限定，E极其父类
Demo: |
public class GenericDemo { public static void main(String[] args) { // 泛型如果明确的写的时候，前后必须一致 Collection<Object> c1 = new ArrayList<Object>(); // Collection<Object> c2 = new ArrayList<Animal>(); // Collection<Object> c3 = new ArrayList<Dog>(); // Collection<Object> c4 = new ArrayList<Cat>();
// ?表示任意的类型都是可以的 Collection<?> c5 = new ArrayList<Object>(); Collection<?> c6 = new ArrayList<Animal>(); Collection<?> c7 = new ArrayList<Dog>(); Collection<?> c8 = new ArrayList<Cat>();
// ? extends E:向下限定，E及其子类 // Collection<? extends Animal> c9 = new ArrayList<Object>(); Collection<? extends Animal> c10 = new ArrayList<Animal>(); Collection<? extends Animal> c11 = new ArrayList<Dog>(); Collection<? extends Animal> c12 = new ArrayList<Cat>();
// ? super E:向上限定，E极其父类 Collection<? super Animal> c13 = new ArrayList<Object>(); Collection<? super Animal> c14 = new ArrayList<Animal>(); // Collection<? super Animal> c15 = new ArrayList<Dog>(); // Collection<? super Animal> c16 = new ArrayList<Cat>(); } }
class Animal { }
class Dog extends Animal { }
class Cat extends Animal { } |
增强for：
是for循环的一种
格式：
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
好处：简化了数组和集合的遍历。
弊端： 增强for的目标不能为null。
如何解决呢?对增强for的目标先进行不为null的判断，然后在使用。
demo： |
public class ForDemo { public static void main(String[] args) { // 定义一个int数组 int[] arr = { 1, 2, 3, 4, 5 }; for (int x = 0; x < arr.length; x++) { System.out.println(arr[x]); } System.out.println("---------------"); // 增强for for (int x : arr) { System.out.println(x); } System.out.println("---------------"); // 定义一个字符串数组 String[] strArray = { "林青霞", "风清扬", "东方不败", "刘意" }; // 增强for for (String s : strArray) { System.out.println(s); } System.out.println("---------------"); // 定义一个集合 ArrayList<String> array = new ArrayList<String>(); array.add("hello"); array.add("world"); array.add("java"); // 增强for for (String s : array) { System.out.println(s); } System.out.println("---------------");
List<String> list = null; // NullPointerException // 这个s是我们从list里面获取出来的，在获取前，它肯定还好做一个判断 // 说白了，这就是迭代器的功能 if (list != null) { for (String s : list) { System.out.println(s); } }
// 增强for其实是用来替代迭代器的 //ConcurrentModificationException // for (String s : array) { // if ("world".equals(s)) { // array.add("javaee"); // } // } // System.out.println("array:" + array); } } |
Demo: ArrayList存储字符串并遍历。要求加入泛型，并用增强for遍历。 A:迭代器 B:普通for C:增强for |
public class ArrayListDemo { public static void main(String[] args) { // 创建集合对象 ArrayList<String> array = new ArrayList<String>();
// 创建并添加元素 array.add("hello"); array.add("world"); array.add("java");
// 遍历集合 // 迭代器 Iterator<String> it = array.iterator(); while (it.hasNext()) { String s = it.next(); System.out.println(s); } System.out.println("------------------");
// 普通for for (int x = 0; x < array.size(); x++) { String s = array.get(x); System.out.println(s); } System.out.println("------------------");
// 增强for for (String s : array) { System.out.println(s); } } } |
