目录
一、去除ArrayList重复字符串
import java.util.ArrayList;
import java.util.Iterator;
public class ListTest {
public static void main(String []args){
ArrayList list=new ArrayList();
list.add("a");
list.add("a");
list.add("b");
list.add("b");
list.add("b");
list.add("c");
list.add("c");
ArrayList newList=getSingle(list);
System.out.println(newList);
}
public static ArrayList getSingle(ArrayList list){
ArrayList newList=new ArrayList<>();
Iterator it=list.iterator();
while(it.hasNext()){
Object obj=it.next();
if(!newList.contains(obj)){
newList.add(obj);
}
}
return newList;
}
}
二、LinkedList特有功能
public void addFirst(E e)//将元素添加到链表头部
public void addLast(E e)//将元素添加到链表尾部
public E getFirst()//获取链表头部元素
public E getLast()//获取链表尾部元素
public E removeFirst()//删除链表头部元素，并返回删除的元素
public E removeLast()//删除链表尾部元素，并返回删除的元素
public E get(int index)//获取指定索引处的元素
三、栈和队列
- 栈
- 先进后出
- 队列
- 先进先出
四、用LinkedList模拟栈数据结构
import java.util.LinkedList;
public class ListTest {
public static void main(String []args){
Stack stack=new Stack();
stack.in("a");
stack.in("b");
stack.in("c");
while(!stack.isEmpty()){
System.out.println(stack.out());
}
}
}
class Stack{
private LinkedList list=new LinkedList();
//模拟进栈
public void in(Object obj){
list.add(obj);
}
//模拟出栈
public Object out(){
return list.removeLast();
}
//判断栈元素是否为空
public boolean isEmpty(){
return list.isEmpty();
}
}
五、泛型
5.1泛型的基本概述
泛型，即“参数化类型”，
就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，
在java中我们一般用<>表示，<>中为引用数据类型，
其作用是限定了集合存储的数据类型，或者说类中操作的数据类型，
5.2泛型的好处
- 提高安全性，将运行期的错误转换到编译期
- 省去强转的麻烦
5.3泛型的使用
public class PatternTest {
public static void main(String []args){
ArrayList<Student> list=new ArrayList<Student>();
list.add(new Student("测试1",20));
list.add(new Student("测试2",21));
list.add(new Student("测试3",22));
list.add(new Student("测试4",23));
Iterator<Student> it=list.iterator();
while(it.hasNext()){
Student stu=it.next();
System.out.println(stu.getName()+" "+stu.getAge());
}
}
}
注意，前后的泛型必须一致，或者后面的泛型可以省略不写，但是尖括号不可以省略<>，
泛型也不要定义成Object，没有意义。
5.4ArrayList存储字符串使用泛型遍历
public class PatternTest {
public static void main(String []args){
ArrayList<String> list=new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
Iterator<String> it=list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
5.5泛型的由来
早期的Object类型可以接受任意的对象类型，
但是在实际的使用中，会有类型转换的问题，也就存在着隐患，
如果在进行类型转换时两个类型不匹配，那么就会抛出ClassCastException，
所以java提供了泛型来解决这个安全问题。
六、泛型类
6.1泛型类概述与使用
将泛型定义在类上，在定义类的时候指定一个类型形参T，
在类中T就当作类型来使用，比如，
class myPattern<T>{
private T t;
public myPattern(T t) {
this.t=t;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}6.2泛型方法概述与使用
将泛型定义在方法上，定义的格式如下，
public <泛型类型> 返回值类型 方法名(泛型类型 形参名)比如，
public <T> void show(T t){
System.out.println(t);
}注意，这里的方法泛型最好与类的泛型一致，如果不一致，需要在方法上声明该泛型。
但是如果为静态方法时，则方法的泛型不能与类泛型一致，必须要声明自己的泛型！
6.3泛型通配符
泛型通配符通常表示为：<?>，
它表示任意类型，如果没有明确，则为Object以及任意的Java类，
List<?> list=new ArratList<String>();//当右边的泛型是不确定时，左边可以指定为？七、增强for循环
7.1增强for循环的概述和使用
增强for是用来简化数组和Collection集合的遍历，比如，
//遍历数组
int arr[]={1,2,3};
for(int i:arr){
System.out.println(i);
}
//遍历集合
ArrayList<String> list=new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
for(String i:list){
System.out.println(i);
}
7.2三种迭代是否能删除
- 普通for循环：可以删除，但是索引要自减
- 迭代器：可以删除，但是必须要使用迭代器自身的remove方法，否则会出现并发修改异常
- 增强for循环：不可以删除，只能遍历
ArrayList<String> list=new ArrayList<String>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
//for循环删除，索引要--
for(int i=0;i<list.size();i++){
if("b".equals(list.get(i))){
list.remove(i--);
}
}
//迭代器删除，用迭代器自身的remove方法
Iterator<String> it=list.iterator();
while(it.hasNext()){
if("b".equals(it.next())){
it.remove();
}
}
//增强for循环不可以删除，只能遍历
for(String str:list){
if("b".equals(str)){
list.remove("b");
}
}
System.out.println(list);八、静态导入
之前我们已经学习了导包，导包是导入一个类，
而这里的静态导入，导入的是一个静态方法，格式如下，
import static 包名.类名.方法名这个方法必须是静态的，如果有多个同名的静态方法，容易不知道是使用哪个类中的方法，这个时候必须要加类前缀，一般不使用，
import static java.util.Arrays.sort;
public class StaicImportTest {
public static void main(String []args){
int arr[]={5,7,4,9,0,1,6,2,8,3};
sort(arr);
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
}
九、可变参数
9.1可变参数概述与使用
如果在定义方法的时候不知道该定义多少个参数，那么我们就会使用可变参数，
使用格式为，
修饰符 返回值类型 方法名(数据类型... 变量名){}这里的变量名就代表了一个数组，可变参数其实和数组类似，但是功能比数组更强大，
可变参数不仅可以接受数组地址作为参数，还可以接受一个实际意义上的数组比如{1,2,3}，还可以什么都不给，
public static void main(String []args){
int arr[]={5,7,4,9,0,1,6,2,8,3};
print(arr);
print(1,2,3);
}
public static void print(int... arr){
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
如果一个方法有可变参数，并且有多个参数，那么可变参数一定要放在最后一个位置。
9.2Arrays工具类的asList()方法
static List<T> asList(T... a)//返回一个受指定数组支持的固定大小的列表这里asList()方法返回值类型是一个集合，接受的参数数组a，功能是将一个数组转换为集合，
这里就用到了可变参数，我们看看这个功能具体如何使用，
String str[]={"a","b","c"};
List list= Arrays.asList(str);
System.out.println(list.toString());
注意，数组转换成集合之后，不能增加删除元素！但是可以使用其他的集合方法。
如果将基本数据类型的数组转换成集合，他会将整个数组当作一个对象转换，也就是会输出数组的地址，
如果一定要将基本数据类型的数组转换成集合，可以换成基本数据类型包装类比如Integer等。
十、集合的嵌套ArrayList
例：我们将一个年级分为若干个班级，班级里有不同的学生，整个年级为一个大集合，而班级又为每个小集合，
这样大集合里面就会嵌套小集合，我们看看如何实现，
ArrayList<ArrayList<Student>> gradeSeven=new ArrayList<>();
ArrayList<Student> classOne=new ArrayList<>();//一班
classOne.add(new Student("一班测试1",20));
classOne.add(new Student("一班测试2",21));
classOne.add(new Student("一班测试3",22));
ArrayList<Student> classTwo=new ArrayList<>();//二班
classTwo.add(new Student("二班测试1",20));
classTwo.add(new Student("二班测试2",21));
//将班级添加到学校中
gradeSeven.add(classOne);
gradeSeven.add(classTwo);
//遍历年级集合，输出年级中的每个人
for(ArrayList<Student> i:gradeSeven){
for(Student j:i){
System.out.println(j);
}
}