Java-泛型和常见的数据结构

集合

集合的体系结构

• 由于不同的数据结构（数据的组织方式），所以Java为我们提供了不同的集合
• 不同的集合的功能是相似的，不断的向上提取，将共性抽取出来，这就是体系结构形成的原因

体系结构：

• 最顶层，包含了所有的共性
• 使用最底层，具体的实现

例如：ArrayList----List-----Collection

package com.it01;

import java.util.ArrayList;


public class CollectionDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList al = new ArrayList();
		al.add("hello");
		al.add("world");
		al.add("java");
		
		for (int x = 0;x<al.size();x++) {
			System.out.println(al.get(x));
		}

	}

}

Collection的常见功能：

• boolean add(E e)
• void clear()
• boolean contains(Object o)
• boolean isEmpty()
• boolean remove(Object o)
• int size()
• Object[] toArray()

package com.it01;

import java.util.ArrayList;
import java.util.Collection;


public class CollectionDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Collection c = new ArrayList();// 多态，父类引用指向子类对象

		// boolean add(E e)
		System.out.println(c.add("hello"));
		System.out.println(c.add("world"));

		System.out.println(c);
		
		//void clear()清空集合
		c.clear();
		System.out.println(c);
		
		//boolean contains(Object o)
		c.add("hello");
		c.add("world");
		System.out.println(c.contains("hello"));
		
		//boolean isEmpty() 
		System.out.println(c.isEmpty());
		
		//boolean remove(Object o)
		System.out.println(c.remove("hello"));
		System.out.println(c);
		
		//int size() 
		System.out.println(c.size());
		
		
		//Object[] toArray() ,将集合变成Object类型数组
		Object[] ob = c.toArray();
		System.out.println(ob[0]);
		
	}

}

集合的遍历方式

• 1-toArray，可以把集合变成数组，遍历数组
• 2-Iterator返回一个迭代器对象，我们可以通过迭代器对象来迭代集合

Iterator：可以用于遍历集合
Iterator iterator()

• E next() ：返回下一个元素
• boolean hasNext() :如果迭代具有更多元素，则返回 true

注意：next()获取下一个元素，如果没有元素可以获取，则出现异常

package com.it02;

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


public class IteratorDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		method1();
		
		method2();
		
	}

	private static void method2() {
		Collection c = new ArrayList();
		
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//获取迭代器对象
		Iterator it = c.iterator();
		
		//E next()  ：返回下一个元素
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}

	private static void method1() {
		//创建集合
		Collection c = new ArrayList();
		
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//获取数组
		Object[] ob = c.toArray();
		//遍历数组
		for(int x=0;x<ob.length;x++) {
			System.out.println(ob[x]);
		}
	}

}

泛型

由于集合可以存储任意类型的对象，当我们存储了不同类型的对象，就有可能在转换的时候出现类型转换的异常，所以提供了泛型机制

泛型：把明确数据类型的工作提前到了编译时期，借鉴了数组的特点
泛型的好处：

• 避免了类型转换的问题
• 可以减少黄色警告
• 可以简化代码的书写

使用：

• API：当我们看到时可以使用

package com.it03;

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

/*
 * 	使用集合存储自定义对象并遍历

 */
public class GenericDemo {

	public static void main(String[] args) {
		//创建集合对象
		Collection<Student> c = new ArrayList<Student>();
		//创建元素对象
		Student s1 = new Student("wangwu", 29);
		Student s2 = new Student("zhangsan", 30);
		//添加元素对象
		c.add(s1);
		c.add(s2);
		//遍历集合对象
		Iterator<Student> it=c.iterator();	
		while(it.hasNext()) {
			Student str =it.next();
			System.out.println(str.name+"----"+str.age);
			
		}
	}

}

class Student{
	String name;
	int age;
	public Student(String name, int age) {
		//super();
		this.name = name;
		this.age = age;
	}
	
	
}

foreach：增强for循环，一般用于遍历集合或者数组

package com.it04;

import java.util.ArrayList;
import java.util.Collection;

/*
 * 	foreach:增强for循环，一般用于遍历集合或者数组
 * 	格式：
 * 		for(元素的类型 变量：集合或者数组对象){
 * 				可以直接使用变量
 * 
 * 		}
 * 
 * 	注意：在增强for循环中不能修改集合，否则会出现并发修改异常
 * 
 * 		
 */
public class ForEachDemo {

	public static void main(String[] args) {
		

		
		
		Collection<String> c = new ArrayList<String>();
		
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//增强for循环，遍历集合
		for(String str:c) {
			System.out.println(str.toUpperCase());
		}
		

	}
	

}

常见的几种数据结构

List集合

List：

• 有序的（存储和读取的顺序是一致的）
• 有整数索引
• 允许重复

几种常见的方法

• void add(int index, E element) ：将指定的元素插入此列表中的指定位置（可选操作）
• E get(int index) ：返回此列表中指定位置的元素
• E remove(int index) ：删除该列表中指定位置的元素（可选操作）。
• E set(int index, E element) ：用指定的元素（可选操作）替换此列表中指定位置的元素

package com.it05;

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


public class ListDemo {

	public static void main(String[] args) {
		//创建列表对象
		List l = new ArrayList();
		
		//添加void add(int index, E element)
		l.add(0,"hello");
		l.add(0,"world");
		l.add(0,"java");
		
		//获取E get(int index)  ：返回此列表中指定位置的元素
		System.out.println(l.get(0));
		
		//E remove(int index) ：删除该列表中指定位置的元素（可选操作）
		System.out.println(l.remove(0));
		
		//E set(int index, E element)  ：用指定的元素（可选操作）替换此列表中指定位置的元素
		System.out.println(l.set(0, "java"));
		
		System.out.println(l);
		
		
	}

}

List的子类

常见子类：

• ArrayList-底层时数组结构，查询快，增删慢
• LinkedList-底层结构是链表，查询慢，增删快

如何使用集合

•  如果查询多，增删少，使用ArrayList
  

•  如果查询少，增删多，使用LinkedList
  

LinkedList的特有方法

• void addFirst(E e)：在该列表开头插入指定的元素
• void addLast(E e)：将指定的元素追加到此列表的末尾
• E getFirst()
• E getLast()
• E removeFirst()
• E removeLast()

package com.it06;

import java.util.LinkedList;


public class LinkedListDemo {

	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		list.add("hello");
		list.add("world");
		

		//void addFirst(E e)：在该列表开头插入指定的元素
		list.addFirst("java");
		
		//void addLast(E e)：将指定的元素追加到此列表的末尾
		list.addLast("android");
		
		System.out.println(list);
		
		//E getFirst()  
		System.out.println(list.getFirst());
		
		//E getLast()  
		System.out.println(list.getLast());
		
		//E removeFirst()  
		System.out.println(list.removeFirst());
		
		//E removeLast()  
		System.out.println(list.removeLast());
		
		System.out.println(list);

	}

}

List测试

package com.it07;

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

/*
 * 	需求：定义一个方法，返回指定列表中指定元素的索引位置
 * 		判断元素是否存在
 */
public class ListTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List list = new ArrayList();
		list.add("hello");
		list.add("java");
		list.add("android");
		int index = getIndex(list,"java");
		System.out.println(index);
		
		
		

	}
	public static int getIndex(List list,Object other) {
		for (int x=0;x<list.size();x++) {
			//获取元素
			Object obj = list.get(x);
			
			if(obj.equals(other)) {
				return x;
			}
		}
		//查找不到
		return -1;
	}
	
	public static boolean contains(List list,Object other) {
		int index = getIndex(list, other);
		if(index>-1) {
			return true;
		}
		return false;
		
	}

}