java集合框架复习

文章目录

三、List集合

listIterator：迭代器

List实现类

1、泛型类

2、泛型接口

三、List集合

特点

有序，打印输出的顺序和添加时的顺序一致（不会帮你自动排序）

有下标，可以通过下标的形式访问对象

元素可以重复

方法

void add(int index,Object o) //在index位置插入元素

boolean addAll(int index,Collection c) //将一个集合中的元素添加到次集合中的index位置

Object get(int index) //返回集合中指定位置的元素

List subList(int fromIndex,int toIndex) //返回二者之间的元素

package com.zheng.demo1;

import java.util.ArrayList;

import java.util.ListIterator;

public class MyList2 {

public static void main(String[] args) {

ArrayList list = new ArrayList();

list.add(2);

list.add(3);

list.add(1);

list.add(5);

list.add(2);

list.add(4);

System.out.println("通过下标访问：" + list.get(0));

ListIterator listIterator = list.listIterator();

while (listIterator.hasNext()) {

System.out.println(listIterator.next());

}

}

}

listIterator：迭代器

hasNext(); 查看是否有下一个元素。有为true，无为false

next(); 取出下一个元素的值

hasPrevious();查看前一个元素是

previous();取出前一个元素

remove(); 删除当前元素

package com.zheng.demo1;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

public class MyList {

public static void main(String[] args) {

//创建一个list集合容器

List list = new ArrayList();

//添加数据

list.add("1-小红");

list.add("2-小黑");

list.add("3-小青");

list.add("4-小紫");

System.out.println("当前集合大小" + list.size());

//一般的遍历

System.out.println("=========一般的遍历=======");

for (int i = 0; i < list.size(); i++) {

System.out.println(list.get(i));

}

System.out.println("=========增强for循环遍历=======");

//增强for循环遍历

for (Object o : list) {

System.out.println(o);

}

System.out.println("=========一般的迭代器遍历=======");

//一般的迭代器遍历

Iterator iterator = list.iterator();

while (iterator.hasNext()) {

System.out.println(iterator.next());

}

System.out.println("=========list迭代器从前到后遍历=======");

//list特有的

ListIterator listIterator = list.listIterator();

while (listIterator.hasNext()) {

String str = (String) listIterator.next();

System.out.println(str);

}

System.out.println("=========list迭代器从后到前遍历=======");

while (listIterator.hasPrevious()) {

Object obj = listIterator.previous();

System.out.println(obj);

}

}

}

List实现类

1、ArrayList【重点】

数据结构实现，查询快（数组是连续的存储地址）。增删慢（每增加或者删除都要移动大量的数据。末尾快一点）

jdk1.2版本。运行效率高，线程不安全

2、Vector:

数组结构，查询快，增删慢

jdk1.0版本，运行效率低，线程安全

3、LinkedList

链表结构实现，增删快（不连续的存储空间，只需要改变节点之间的指向）查询慢

package com.zheng.demo1;

import java.util.LinkedList;

import java.util.ListIterator;

public class MyLinkList {

public void print(LinkedList students) {

//迭代器遍历

System.out.println("======迭代器遍历======");

ListIterator studentListIterator = students.listIterator();

while (studentListIterator.hasNext()) {

Student student = studentListIterator.next();

System.out.println(student);

}

}

public static void main(String[] args) {

MyLinkList myLinkList = new MyLinkList();

//1、创建一个容器

LinkedList students = new LinkedList<>();

//2、创建对象

Student student1 = new Student(1, "小黑", "周口");

Student student2 = new Student(2, "小名", "沈丘");

Student student3 = new Student(3, "小郑", "范营乡");

Student student4 = new Student(4, "小芳", "666");

//3、将对象加入集合

students.add(student1);

students.add(student2);

students.add(student3);

students.add(student4);

//查看

System.out.println(students.toString());

//调用迭代器遍历

myLinkList.print(students);

//删除

System.out.println("=====删除某个元素=====");

students.remove(1);

myLinkList.print(students);

}

}

四、泛型jdk1.5中引入的新特性。本质是参数化类型，把类型当做参数传递

泛型接口、泛型方法、泛型类

T为占位符，表示一种引用类型

优点：（1）、提高代码的复用。（2）、防止类型转换异常，提高代码的安全性

1、泛型类

泛型变量

泛型作为传递的参数

泛型作为方法的返回值

注意：

泛型只能使用引用类型

不同泛型类型对象之间不能相互赋值

package com.zheng.demo2;

//泛型类

public class MyGeneric {

T t;//1、泛型变量

//2、泛型作为传递的参数

public void show(T t) {

System.out.println(t);

}

//3、泛型作为方法的返回值

public T getT() {

return t;

}

}

package com.zheng.demo2;

public class TestMyGeneric {

public static void main(String[] args) {

//使用泛型类创建对象

MyGeneric sm = new MyGeneric<>();

sm.t = "你好";

sm.show("呦呦呦");

System.out.println(sm.getT());

System.out.println("=============");

MyGeneric im = new MyGeneric<>();

im.t = 999;

im.show(666);

System.out.println(im.getT());

}

}

2、泛型接口

package com.zheng.demo2;

public interface MyInterface {

T show(T t);

}

实现类

package com.zheng.demo2;

public class MyInterfaceImpl1 implements MyInterface{

@Override

public Integer show(Integer integer) {

return integer;

}

public static void main(String[] args) {

MyInterfaceImpl1 impl1 = new MyInterfaceImpl1();

System.out.println(impl1.show(999));

}

}

2、

package com.zheng.demo2;

public class MyInterfacetImpl implements MyInterface{

public String show(String s) {

return s;

}

public static void main(String[] args) {

MyInterface omf = new MyInterfacetImpl();

System.out.println(omf.show("hhhhhh"));

}

}

3、

package com.zheng.demo2;

public class MyInterfaceImpl2 implements MyInterface {

@Override

public T show(T t) {

return t;

}

public static void main(String[] args) {

MyInterfaceImpl2 impl2 = new MyInterfaceImpl2<>();

System.out.println(impl2.show("daoajao"));

System.out.println("============");

MyInterfaceImpl2 impl21 = new MyInterfaceImpl2<>();

System.out.println(impl21.show(520.1313));

}

}

3、泛型方法

package com.zheng.demo2;

public class MyGenericMethod {

//泛型方法

public T show(T t) {

System.out.println("泛型方法" + t);

return t;

}

public static void main(String[] args) {

System.out.println(new MyGenericMethod().show(5));

System.out.println("=============");

System.out.println(new MyGenericMethod().show("哈哈哈哈"));

}

}