本文深入讲解Java中的List集合，包括其内部实现原理如数组和链表结构，不同子类的特点对比，以及如何去除重复元素等实用技巧。同时，介绍了泛型的概念与应用，以及增强for循环的使用方法。
------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------
集合List总结
Collection
|--List
元素有序(存储和取出顺序一致)，可以重复
|--Set
元素无序，唯一
这里主要讲List
01、栈和队列数据结构
1、了解常见的数据结构
栈 队列 堆 数组 链表 红黑树 图 哈希结构......
栈：先进后出
队列：先进先出
02、数组-数据结构
数组数据
概念：存储多个同一种类型的容器
特点：是存在索引的
优点：查询快
缺点：增删慢
03、链表-数据结构
链表数据
概念：把一些节点用链子连接起来的数据结构
优点：增删快
缺点：查询慢
04、List三个子类特点
ArrayList类的特点：
底层是数组结构 增删慢,查询快.线程不安全,效率高
Vector类的特点：
底层是数组结构, 增删慢,查询快.线程安全,效率低
LinkedList类的特点:
底层是链表结构. 增删快,查询慢.线程不安全,效率高
05、获得一个没有重复元素的新集合
实例：
import java.util.ArrayList;
import java.util.Iterator;
public class OnlyElement {
public static void main(String[] args) {
ArrayList<Student> al = new ArrayList<Student>();
al.add(new Student("比卡丘", 20));
al.add(new Student("小火龙", 20));
al.add(new Student("车里龟", 20));
al.add(new Student("奇异种子", 20));
al.add(new Student("宝石海星", 20));
al.add(new Student("鲤鱼王", 21));
for(int i = 0; i < al.size(); i++)
System.out.println("after only:"+ al.get(i).getName()+"-----"+al.get(i).getAge());
al = getOnlyElement(al);
System.out.println("-----------------");
for(int i = 0; i < al.size(); i++)
System.out.println("before only:"+ al.get(i).getName()+"-----"+al.get(i).getAge());
}
//创建一个新的ArrayLis，t 遍历al， 判断newAl是否包含了al中的元素，是就添加。
public static ArrayList<Student> getOnlyElement(ArrayList<Student> al){
ArrayList<Student> newAL = new ArrayList<Student>();
Iterator<Student> it = al.iterator();
while(it.hasNext())
{
Student str = it.next();
//类类型要用contains要重写equals
if(!newAL.contains(str)){
newAL.add(str);
}
}
return newAL;
}
}
public class Student {
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
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;
}
@Override
public boolean equals(Object obj) {
//提高运行效率
if(this == obj)
{
return true;
}
//提高健壮性
if(!(obj instanceof Student))
{
return false;
}
//向下转型
Student stu = (Student)obj;
return this.name.equals(stu.name) && this.age == stu.age;
}
}07、LinkedList的特有功能
A：添加功能
void addFirst(Object o )
向集合中开头位置添加元素
void addLast(Object o )
向集合的末尾添加元素
B：获取功能
Object getFirst()
获取集合中的第一个元素
Object getLast()
获取集合中最后一个元素
C：删除功能
ObjectremoveFirst()
删除集合中第一个元素
ObjectremoveLast()
删除集合中最后一个元素
08、用LinkedList模拟栈数据结构
自定义栈结构实例：
import java.util.LinkedList;
//栈结构的存取是 后进先出
public class MyStack {
//私有化，只能通过公共接口访问
private LinkedList ll;
//在构造方法中指向对象
public MyStack() {
super();
ll = new LinkedList();
}
//把后进的对象压在结构的第一位
public void add(Object obj){
ll.addFirst(obj);
}
//根据索引获取元素
public Object get(int index){
return ll.get(index);
}
//定义size方法，方便遍历
public int size(){
return ll.size();
}
}
09、泛型的概述和简单使用
概念：任意数据类型,是一种把明确数据类型的操作放在了创建对象的时候
或者调用方法的时候进行的特殊类型
格式：<数据类型>
泛型的好处
A：解决eclipse黄色警告线问题
B：把运行时期的类型转换异常提前到了编译期
C：优化了程序设计
泛型什么时候用
API中类或者接口名后边有<>那么就可以使用泛型.
泛型一般我们在集合中去使用
泛型高级(通配符)
?:表示任意的类型都是可以的,就是Object以及任意的Java类
<? extends E> : 向下限定，E及其子类
<? super E >: 向上限定，E及其父类
通配符实例代码：
class fangxinDemo
{
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
{
}
}10、增强for的概述和使用
格式for(要遍历元素的数据类型 变量名 ： 集合或数组的对象名)
{
直接使用变量名即可
}
注意:增强for是为了取代迭代器的,所以说在用增强for遍历集合的过程中
对集合进行改变,也会出现并发修改异常.
代码实例：
import java.util.ArrayList;
/*
* 增强for循环:
* 格式：
* for(数组或者Collection集合中元素类型 变量名 : 数组或者Collection集合对象)
* {
* 使用变量名即可。
* }
*
* 作用：简化数组和Collection集合的变量。
* 注意：增强for是用来替代迭代器的。不能再用增强for的时候，用集合对象对集合进行改变。
*/
public class ForDemo {
public static void main(String[] args) {
// 整型数组
int[] arr = { 1, 2, 3, 4, 5 };
// 普通for
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 = { "hello", "world", "java" };
// 增强for
for (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");
// ConcurrentModificationException
ArrayList<String> array2 = null;
// NullPointerException
for (String str : array2) {
if (str.equals("world")) {
array2.add("EE");
}
}
}
}
11、泛型类
需求：我能不能不用重载方法，就可以实现同一个方法，输出不同类型的数据呢？
使用泛型类就可以实现
泛型类就是把泛型加在类后面
代码实例：
/*
* 泛型类：把泛型定义在类上。
*/
public class Tool2<QQ> {
public void show(QQ qq) {
System.out.println(qq);
}
}12、泛型方法
你为了保证方法传递不同的参数，你就在类上明确了类型。
那如果想在方法被调用的时候才明确数据类型怎么办？
可以用泛型方法 把泛型加在方法声明上
代码实例
/*
* 为了保证方法传递不同的参数，就在类上明确了类型。
* 这样的话，有没有发现一个问题呢？
* 它要是能够在调用方法的时候，才去明确类型该有多好呢?
*
* 泛型方法：把泛型加在方法上。
*/
public class Tool {
public <BYD> void show(BYD byd) {
System.out.println(byd);
}
}
注意位置:加在返回值类型前面.
扫一扫
446
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
