目录
去除ArrayList中重复字符串元素方式
解题思路：创建一个新集合，如果集合中有该元素就不添加，如果不包含则添加，这样得到的集合元素就都是唯一的
import java.util.ArrayList;
import java.util.Iterator;
public class demo {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList list =new ArrayList();
list.add("a");
list.add("a");
list.add("b");
list.add("c");
list.add("c");
ArrayList l = tiqu(list);
System.out.println(l);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public static ArrayList tiqu(ArrayList list) {
ArrayList l = new ArrayList(); //创建新集合
Iterator it = list.iterator(); //根据传入的集合创建迭代器
while(it.hasNext()) { //遍历集合
Object obj = it.next(); //记录元素
if(!l.contains(obj)) { //如果新集合中不包含该元素
l.add(obj); //在新集合中添加该元素
}
}
return l;
}
}
去除ArrayList中重复自定义对象元素
注意：解决思路跟上一个题是一样的，但是contains方法判断是否包含是底层依赖的是equals方法，比较的是对象的地址值因此需要重写，我这里在定义person类里面重写了。（remove方法底层依赖的也是equals方法因此使用时也需要重写）
person类
package com.Person;
public class Person {
private String name;
private int age;
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(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 String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
Person p =(Person)obj;
return this.name.equals(p.name) && this.age ==p.age;
}
}
import java.util.ArrayList;
import java.util.Iterator;
import com.Person.Person;
public class demo1 {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList list = new ArrayList();
list.add(new Person("张三",23));
list.add(new Person("张三",23));
list.add(new Person("李四",24));
list.add(new Person("李四",24));
list.add(new Person("李四",24));
list.add(new Person("张三",23));
list.add(new Person("张三",23));
ArrayList l =tiqu(list);
System.out.println(l);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public static ArrayList tiqu(ArrayList list) {
ArrayList l = new ArrayList(); //创建新集合
Iterator it = list.iterator(); //根据传入的集合创建迭代器
while(it.hasNext()) { //遍历集合
Object obj = it.next(); //记录元素
if(!l.contains(obj)) { //如果新集合中不包含该元素
l.add(obj); //在新集合中添加该元素
}
}
return l;
}
}
LinkedList的特有功能
public viod addFirst(E e)及addLast(E e)
public E getFirst()及getLast()
public E removeFirst()及removeLast()
public E get (int index)
用LinkedList模拟栈数据结构的集合
定义栈结构（栈是先进后出类型的，队列是先进先出，因此想要实现队列结构只需要把removelast（）改成removeFirst())
package com.list;
import java.util.LinkedList;
public class stack {
private LinkedList list = new LinkedList();
/*
* 模拟进栈方法
*/
public void push(Object obj) {
list.addLast(obj);
}
/*
* 模拟出栈
*/
public Object out() {
return list.removeLast();
}
/*
* 模拟栈结构是否为空
*/
public boolean isEmpty() {
return list.isEmpty();
}
}
运行
package com.list;
public class demo4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
stack s =new stack();
s.push("a");
s.push("b");
s.push("c");
s.push("d");
while(!s.isEmpty()) {
System.out.println(s.out());
}
}
}
泛型（generic概述和基本使用）
概述：限定集合类型
好处：提高安全性（将运行期的 错误转换到编译期），省去强转的麻烦
基本使用：<>中放的必须是引用数据类型
使用注意事项：
前后泛型必须一致，或者后面的泛型可以省略不写（1.7的新特性菱形泛型）
next()方法只能调用一次，如果调用多次会将指针向后移动多次。
ArrayList存储字符串和自定义对象并遍历（泛型）
import jaimport java.util.ArrayList;
import java.util.Iterator;
import com.Person.Person;
public class demo5 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//demo(); //存储字符串并遍历
ArrayList<Person> al = new ArrayList<>();
al.add(new Person("张三",23));
al.add(new Person("李四",24));
al.add(new Person("王五",25));
Iterator<Person> it = al.iterator();
while(it.hasNext()) {
Person p = it.next() ;
System.out.println(p.getAge()+p.getName());
}
}
public void demmo() {
ArrayList<String> al = new ArrayList<>();
al.add("park");
al.add("zhang");
al.add("loey");
al.add("lay");
Iterator<String> it = al.iterator();
while(it.hasNext()) {
System.out.println();
}
}
}
泛型的由来
通过Object转型问题引入。早期的Object类型可以接收任意类型的对象类型，但是在实际使用中，会有类型转换的问题，也就存在隐患，所以java提供了泛型
泛型类概述及使用
泛型类概述<T>（把泛型定义在类上）
格式：public class 类名<泛型类型1,....>
注意事项：泛型必须是引用类型
泛型方法的概述以及使用
非静态方法泛型最好是与类的泛型一致 如果不一致需要在方法上声明泛型
静态方法由于是随着类的加载而加载的，而泛型是随着对象的创建而存在的，因此静态方法的类需要声明自己的泛型
概述：把泛型定义在方法上
定义格式：public <泛型类型> 返回类型 方法名（泛型类型 变量名）
泛型接口的概述与使用
public class demo7 {
public static void main(String[] args) {
}
}
interface Inter<T> {
public void show(T t);
}
//class demo implements Inter<String> {
//
// @Override
// public void show(String t) {
// // TODO Auto-generated method stub
// System.out.println(t);
// }
//
//}
class demo<T> implements Inter<T> { //没有必要在实现接口时给自己类加泛型
@Override
public void show(T t) {
// TODO Auto-generated method stub
System.out.println(t);
}
}泛型高级之通配符
泛型通配符<?>
任意类型，如果没有明确，那么就是Object以及任意的Java类了
？ extends E
向下限定E及其子类
？ super E
向上限定E及其父类
import java.util.ArrayList;
import com.Person.Person;
import com.Person.Student;
public class demo8 {
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<Person> lista = new ArrayList<>();
lista.add(new Person("张三",23));
lista.add(new Person("李四",24));
ArrayList<Student> listb = new ArrayList<>();
listb.add(new Student("王五",25));
listb.add(new Student("赵六",26));
lista.addAll(listb);
System.out.println(lista);
}
}
Student是继承Person的，Student自动类型提升为Person。
增强for的概述和使用
简化数组和Collection集合的遍历
格式：
for(元素数据类型 变量：数组或Collection集合）{
使用变量即可，该变量就是元素。
}
好处：简化遍历
import java.util.ArrayList;
public class demo9 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = {1,2,3};
for(int i:arr) {
System.out.println(i);
}
ArrayList<String> list =new ArrayList<>();
list.add("qw");
list.add("a");
for(String string:list) {
System.out.println(string);
}
}
}
ArrayList存储自定义对象并遍历增强for版
import java.util.ArrayList;
import com.Person.Person;
public class demo10 {
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<Person> list = new ArrayList<>();
list.add(new Person("张三",23));
list.add(new Person("李四",24));
for(Person p :list) {
System.out.println(p);
}
}
}
三种迭代的能否删除
普通for循环，可以删除，但是索引要--
迭代器，可以删除，但是必须使用迭代器自身的remove方法，否则会出现并发修改异常
增强for循环不能删除
import java.util.ArrayList;
import java.util.Iterator;
public class dem10 {
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
//1.普通for循环(但是如果两个元素相邻，只能删除一个，因此需要添加一个i--）
for(int i = 0;i<list.size();i++) {
if("b".equals(list.get(i))) {
list.remove(i--);
}
}
System.out.println(list);
//2.迭代器删除
Iterator<String> it = list.iterator();
while(it.hasNext()) {
if("b".equals(it.next())) {
it.remove();
}
}
System.out.println(list);
}
}
静态导入的概述和使用
导入类中的静态方法
格式：
import static 包名.类名.方法名;
可以直接导入到方法的级别
注意事项：
方法必须是静态的，如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用但是要能看懂。
可变参数的概述和使用
定义方法是不知道该定义多少个参数
格式：
修饰符 返回值类型 方法名（数据类型 ... 变量名){}
注意事项
这里的变量其实是一个数组
如果一个方法有可变参数，并且有多个参数，那么可变参数肯定是最后一个
public class demo11 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = {11,22,33,44,55};
print(arr);
print();
print(11,22,33,44,55);
}
/* public static void print(int[] arr) {
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}*/
public static void print(int ... arr) { //可变参数其实就是一个数组
for(int i =0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
Arrays工具类的asList()方法的使用
数组转换成集合虽然不能增加或减少元素，但是可以用集合的思想操作数组，也就是说可以使用集合中的方法
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class demo12 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//集合转数组
ArrayList<String> list = new ArrayList<>();
list.add("a");
String[] arr = list.toArray(new String[0]); //当集合转换数组是，数组长度如果是小于等于集合的size时，转换后的数组长度等于集合的size
//如果数组长度大于集合的size，分配数组的长度就和你指定的长度一样
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
public static void demo() {
String[] arr = {"a","b","c"};
List<String> list = Arrays.asList(arr); //将数组转换成集合
System.out.println(list);
}
public static void demo1() {
// int[] arr = {11,22,33,44};
// List list = Arrays.asList(arr); //将数组转换成集合
// System.out.println(list); //基本数据类型转换成集合,会把数组整体当成一个对象因此输出地址值[[I@5594a1b5]
Integer[] arr = {11,22,33,44}; //将数组转集合，数组必须是引用数据类型
List<Integer> list = Arrays.asList(arr);
System.out.println(list);
}
}
集合嵌套之ArrayList嵌套ArrayList
学科分为若干个班级，整个学科为一个大集合，若干个班级分为一个小集合
import java.util.ArrayList;
import com.Person.Person;
public class demo13 {
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<ArrayList<Person>> list = new ArrayList<>();
ArrayList<Person> first = new ArrayList<>();
first.add(new Person("张艺兴",30));
first.add(new Person("朴灿烈",29));
ArrayList<Person> second = new ArrayList<>();
second.add(new Person("LAY ZHANG",30));
second.add(new Person("PARK CHANYEOL",29));
list.add(first);
list.add(second);
for(ArrayList<Person> a :list) {
for(Person p :a) {
System.out.println(p);
}
}
}
}
965
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
