List接口及其子类的特点和遍历方式

ArrayList存储字符串并遍历

List的子类特点:
ArrayList:
底层数据结构是数组,查询快,增删慢
线程不安全,效率高
Vector:
底层数据结构是数组,查询快,增删慢
线程安全,效率底
LinkedList:
底层数据结构是链表,查询慢,增删快
线程不安全,效率高

案例:
使用List的任意子类存储字符串或者存储自定义对象并遍历

ArrayList的使用。
存储字符串并遍历。

public class ArrayListDemo {
	public static void main(String[] args) {
		//创建集合对象
		ArrayList al = new ArrayList();
		
		//把字符串元素添加到集合对象中
		al.add("hello");
		al.add("world");
		al.add("java");
		
		//集合遍历
		Iterator it = al.iterator();
		while(it.hasNext()){
			String s = (String)it.next();
			System.out.println(s);
		}
		System.out.println("---------------");
		
		for(int x = 0;x<al.size();x++){
			String s = (String) al.get(x);
			System.out.println(s);
		}
	}
}

Vector的特有功能

A:Vector类概述: Vector 类可以实现可增长的对象数组 , Vector 是同步的。
B:Vector类特有功能
public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()
C:案例演示: Vector的特有功能演示

A:Vector类概述:	Vector 类可以实现可增长的对象数组 , Vector 是同步的。 
B:Vector类特有功能
	public void addElement(E obj)
	public E elementAt(int index)
	public Enumeration elements()
C:案例演示:	Vector的特有功能演示

LinkedList的特有功能

A:LinkedList类概述: List 接口的链接列表实现 , 此实现不是同步的
B:LinkedList类特有功能
public void addFirst(E e)及addLast(E e)
public E getFirst()及getLast()
public E removeFirst()及public E removeLast()
C:案例演示
LinkedList的特有功能演示
注意：LinkedList 底层数据结构是链表，查询慢，增删块，线程不安全，效率高

 LinkedList linkedList = new LinkedList();
        linkedList.add("哈哈1");
        linkedList.add("哈哈2");
        linkedList.add("哈哈3");
        linkedList.add("哈哈4");
        linkedList.add("哈哈5");
        linkedList.add("哈哈6");
                Object pop = linkedList.pop();
        Object pop1 = linkedList.pop();
        System.out.println(pop);
        System.out.println(pop1);
        System.out.println(linkedList);
        linkedList.push("hahaha111");
        linkedList.push("hahaha3222");
        System.out.println(linkedList)；
    }
}

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

 1 /*
 2  *需求：请用LinkedList模拟栈数据结构的集合，并测试
 3  *创建一个类将Linked中的方法封装
 4  */
 5 public class Demo4_LinkedList {
 6     public static void main(String[] args) {
 7         Stack stack = new Stack();
 8         stack.in("a");
 9         stack.in("b");
10         stack.in("c");
11         stack.in("d");
12         while (!stack.isEmpty()) {
13             System.out.println(stack.out());
14         }
15     }
16 }

 3 public class Stack {
 4     @SuppressWarnings("rawtypes")
 5     private LinkedList list = new LinkedList();
 6 
 7     @SuppressWarnings("unchecked")
 8     public void in(Object obj) {// 模拟进栈
 9         list.addLast(obj);
10     }
11 
12     public Object out() {// 模拟出栈
13         return list.removeLast();
14     }
15 
16     public boolean isEmpty() {// 判断是否为空
17         return list.isEmpty();
18     }

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

：案例演示

需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
思路：创建新集合方式

public class Demo01_ArrayList {

	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add("a");
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("c");
		list.add("c");
		list.add("c");
		
		ArrayList newList = getSingle(list);
		System.out.println(newList);
	}

 * 创建新集合将重复元素去掉
 * 1.明确返回值类型,返回ArrayList
 * 2.明确参数列表ArrayList
 * 
 * 分析:
 * 1.创建新集合
 * 2.根据传入的集合(老集合)获取迭代器
 * 3.遍历老集合
 * 4.通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加

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中重复自定义对象元素

A:案例演示
需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
B:注意事项
重写equals()方法

    public void setName(String name) {
         this.name = name;
     }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
     @Override
     public String toString() {
         return "Person [name=" + name + ", age=" + age + "]";
     }
     @Override
     public boolean equals(Object obj) {//重写equals方法
         Person per = (Person) obj;
         if (per.getName().equals(this.name) && per.getAge() == this.age) {
             return true;
         }
         return false;
     }
}
```

```
public class Person {
      private String name;
      private int age; 
     public Person(String name, int age) {
          super();
         this.name = name;
         this.age = age;
     }
     public String getName() {
         return name;
     }

泛型概述和基本使用

泛型概述:是一种把类型明确的工作
推迟到创建对象
或者调用方法的时候才去明确的特殊的类型。
参数化类型，把类型当作参数一样的传递。
泛型的格式 : <数据类型> 这里的数据类型只能是引用数据类型
泛型好处
(1): 把运行时期的问题提前到了编译期间
(2): 避免了强制类型转换
(3):优化了程序设计，解决了黄色警告线
注意：泛型只在编译期有效 但在运行期就擦除了
泛型基本使用

ArrayList存储字符串并遍历泛型版

////把类型明确工作，推迟到创建对象，或调用方法时，才去明确的一种机制

   public class MyTest2 {
   public static void main(String[] args) {
   
    MyClass<String> stringMyClass = new MyClass<>();
    stringMyClass.setT("abc");
    String t = stringMyClass.getT();


    MyClass<Integer> integerMyClass = new MyClass<>();
    integerMyClass.setT(100);
    Integer t1 = integerMyClass.getT();

}

}