版权声明:本文为博主原创文章,转载请标明出处。https://blog.csdn.net/kXYOnA63Ag9zqtXx0/article/details/82954503 https://blog.csdn.net/forever428/article/details/83065541
文章目录
ArrayList
public static void main(String[] args) {
//* List:特有方法,可以操作下标
List list = new ArrayList<>();
//1.增:
//void add(int index, E element)
list.add("java");
list.add(0, "python");
list.add("html");
list.add("java1");
list.add("BigData");
System.out.println(list);
//boolean addAll(int index, Collection<? extends E> c)
//2.删
//E remove(int index) 这里可以将E暂时理解成Object
System.out.println(list.remove(0));
System.out.println(list);
//3.改
//E set(int index, E element)
System.out.println(list.set(0, "iOS"));
System.out.println(list);
//4.查
//ListIterator<E> listIterator()
//返回此列表元素的列表迭代器(按适当顺序)。
test(list);
//ListIterator<E> listIterator(int index)
//List<E> subList(int fromIndex, int toIndex) 包含开头不包含结尾
List list2 = list.subList(1, 3);
System.out.println(list2);
//E get(int index)
System.out.println(list.get(0));
//5.删除全部对象
list.clear();
}
//4.查
//ListIterator<E> listIterator()
public static void test(List list){
//获取迭代器对象
ListIterator iterator = list.listIterator();
//从左到右遍历
while (iterator.hasNext()) {
Object object = (Object) iterator.next();
System.out.println("从左到右:"+object);
}
//从右到左遍历
while (iterator.hasPrevious()) {
Object object = iterator.previous();
System.out.println("从右到左:"+object);
}
//注意事项:
while (iterator.hasNext()) {
Object object = (Object) iterator.next();
System.out.println("从左到右:"+object);
//需求:将list中的html删除
if (object.equals("html")) {
//在使用迭代器遍历集合期间,使用list的删除方法直接删除元素,有可能发生错误,所以不要这样做,
//使用迭代器自带的方法进行删除
//list.remove("html");
//注意:在ListIterator中包含remove,set,add方法.但是注意最好不要同时使用.
iterator.remove();
// iterator.set(e);
// iterator.add(e);
}
}
}
public static void main(String[] args) {
//Vector:了解
//不同点:遍历的时候使用的是枚举器
//创建存值
Vector vector = new Vector<>();
vector.add("java1");
vector.add("java2");
vector.add("java3");
vector.add("java4");
System.out.println(vector);
//遍历--枚举器
//获取枚举器对象
Enumeration enumeration = vector.elements();
//遍历
while (enumeration.hasMoreElements()) {
Object object = (Object) enumeration.nextElement();
System.out.println(object);
}
}
LinkedList
public static void main(String[] args) {
//LindedList
LinkedList linkedList = new LinkedList<>();
// 特有的方法:
//
// addFirst()//始终在首位添加
// addLast()//始终在末尾添加
linkedList.addFirst("java");
linkedList.addLast("python");
linkedList.add("iOS");
linkedList.add(1, "html");
linkedList.addFirst("BigData");
System.out.println(linkedList);
// getFirst()//获取的对象不存在会发生异常:NoSuchElementException
// getLast()
System.out.println(linkedList.getFirst());
// removeFirst()//删除的对象不存在会发生异常
// removeLast()
System.out.println(linkedList.removeFirst());
// 从jdk1.6开始出现以下方法
// offerFirst()
// offerLast()
linkedList.clear();
// peekFirst()//获取的对象不存在会返回null
// peekLast()
System.out.println(linkedList.peekFirst());
// pollFirst()//删除的对象不存在会返回null
// pollLast()
System.out.println(linkedList.pollFirst());
}
ArrayList
- 实例:list特点是有序的,可以重复的
- 要求:使用list存储数据,但是数据不能重复—利用contains方法
public static void main(String[] args) {
ArrayList arrayList = new ArrayList<>();
arrayList.add("java1");//第一个元素
arrayList.add("java2");//第二个元素
arrayList.add("java2");//第三个元素
arrayList.add("java3");
arrayList.add("java4");
arrayList.add("java5");
System.out.println(arrayList);
//创建一个临时的集合用于存储不重复的元素
ArrayList arrayList1 = new ArrayList<>();
//遍历元素集合
Iterator iterator = arrayList.iterator();
while (iterator.hasNext()) {
Object object = (Object) iterator.next();
//向下转型
String string = (String)object;
//如果新的集合中不包含当前的元素,就将当前的元素添加进去
/*
* 原理:在添加新元素的时候,返回调用元素的equals方法,去比较,所有的都返回false,整体认为是false.有一次比较
* 返回true,整个contains的结果就是true
*
* 添加第三个元素的过程:
* 第三个元素.equels("java1") = false 继续比 第三个元素.equels("java2") = true 停止比较
*/
if (!arrayList1.contains(string)) {
arrayList1.add(string);
}
}
System.out.println(arrayList1);
}
练习:创建一个类:狗类 属性:姓名,年龄
- 要求:创建一个集合保存3个狗对象,第一个拉布拉多 第二个:金毛 第三:博美,分别根据年龄和姓名去重
public class Demo8 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add(new Dog("拉布拉多", 20));
list.add(new Dog("金毛", 20));
list.add(new Dog("博美", 23));
list.add(new Dog("金毛", 26));
System.out.println(list);
ArrayList list1 = new ArrayList<>();
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object object = (Object) iterator.next();
if (!list1.contains(object)) {
list1.add(object);
}
}
System.out.println(list1);
}
}
class Dog{
String name;
int age;
public Dog(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
//:按照人的年龄和姓名比较.只要年龄和姓名一致就认为是一个人.
public boolean equals(Object obj) {
if (!(obj instanceof Dog)) {
throw new ClassCastException();
}
//向下转型
Dog person = (Dog)obj;
//return this.age==person.age && this.name.equals(person.name);
//根据年龄比
//return this.age == person.age;
//根据姓名
return this.name.equals(person.name);
}
}
Set:无序的,不可重复的
- HashSet:底层是哈希表,线程不安全的
- TreeSet:底层是二叉树,线程不安全的
-
HashSet实现去重的方法:是通过调用元素的hashCode和equals方法实现去重.首先会调用hashCode方法,比较两个元素的哈希码值,如果哈希码值不同直接认为是两个对象,停止比较.如果相同,再去使用equals.返回true认为是一个对象,返回false认为是两个对象.
-
TreeSet:实现去重和排序的方式:
- 让实现Comparable接口,重写compareTo方法
- 创建比较器类,让他实现Comparator重写compare方法,再将比较器对象作用于TreeSet,内部的元素会按照比较器进行比较.
-
总结:
- hashSet只能实现去重,不能排序
- 对于自定义的类要想按照自己制定的规则去重,必须重写hashcode和equals方法
public class Demo9 {
public static void main(String[] args) {
HashSet set = new HashSet<>();
/*
* 在add内部实现的去重的功能.默认调用字符串的hashCode和equals方法.
* 在String中是重写了hashCode和equals方法,所以可以保证在进行比较的时候,比较的是内容.
*/
set.add("java1");
set.add("java4");
set.add("java2");
set.add("java5");
set.add("java2");
System.out.println(set);
/*
* 打印结果:[java5, java4, java2, java1]
* 说明:实现了去重
*/
//实例:将Person1的对象存入Set,按照姓名和年龄比较
HashSet set1 = new HashSet<>();
set1.add(new Person1("bingbing1", 18));
set1.add(new Person1("bingbing2", 18));
set1.add(new Person1("bingbing3", 183));
set1.add(new Person1("bingbing3", 183));
set1.add(new Person1("bingbing4", 186));
System.out.println(set1);
/*
* 打印结果:[Person1 [name=bingbing4, age=186], Person1 [name=bingbing1, age=18], Person1 [name=bingbing2, age=18], Person1 [name=bingbing3, age=183]]
* 说明:对自定义的类实现了去重
*/
}
}
class Person1{
String name;
int age;
public Person1(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person1 [name=" + name + ", age=" + age + "]";
}
//重写hashCode方法
@Override
public int hashCode() {
return name.hashCode()+age*1000;
}
//重写equals方法,制定自己的比较规则:只要年龄和姓名相同就认为是同一个人
@Override
public boolean equals(Object obj) {
//容错处理
if (!(obj instanceof Person1)) {
throw new ClassCastException("类型转化异常");
}
//向下转型
Person1 person = (Person1)obj;
return this.name.equals(person.name) && this.age == person.age;
}
}
TreeSet:实现去重和排序的方式:
- 让元素去实现Comparable接口,重写comparo方法------默认排序
- 创建比较器类,让他实现Comparetor接口写compare方法,再将比较器对象作用于TreeSet,内部的元素会按照比较器进行比较.—人工排序
树的结构
二叉树
package com.qianfeng.test;
import java.util.HashSet;
import java.util.TreeSet;
public class Demo10 {
public static void main(String[] args) {
//学习第一种
//1.让元素去实现Comparable接口,重写compareTo方法------默认排序
TreeSet set = new TreeSet<>();
//使用TreeSet在存储字符串的时候自动实现了排序和去重
//因为在add方法中调用了Comparable接口的compareTo方法
//默认是按照升序字典顺序排序
set.add("java1");
set.add("java4");
set.add("java2");
set.add("java5");
set.add("java2");
System.out.println(set);
//实例:将Person2的对象存入TreeSet,按照姓名和年龄比较
TreeSet set1 = new TreeSet<>();
set1.add(new Person2("bingbing1", 18));
set1.add(new Person2("bingbing2", 18));
set1.add(new Person2("bingbing3", 183));
set1.add(new Person2("bingbing3", 183));
set1.add(new Person2("bingbing0", 17));
System.out.println(set1);
}
}
//自定义的类实现Comparable接口
class Person2 implements Comparable{
String name;
int age;
public Person2(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person2 [name=" + name + ", age=" + age + "]";
}
@Override
//自己制定的规则:按照年龄和姓名比较
/*
*返回正数,代表前面的比后面的大
*返回0,代表前后相等
*返回负数,代表前面的比后面的小
*/
public int compareTo(Object o) {
if (!(o instanceof Person2)) {
throw new ClassCastException("类型转换错误");
}
//向下转型
Person2 person2 = (Person2)o;
//先按照年龄比较,年龄相同再去比姓名
int num = age-person2.age;
return num==0?name.compareTo(person2.name):num;
}
}
创建比较器类
让他实现Comparetor接口,重写compare方法,再将比较器对象作用于TreeSet,
//内部的元素会按照比较器进行比较.—人工排序
- 实例:要求按照字符串的长度对字符串进行排序–从短到长
- 步骤1:创建比较器类实现Comparetor接口,重写compare方法
- 步骤2:创建比较器对象,并指定给存储元素的TreeSet
- 总结:对TreeSet排序有两种方式.默认排序(系统排序)和人工排序
- 注意:人工排序的优先级高于默认排序.
public class Demo11 {
public static void main(String[] args) {
//第二种
//2.创建比较器对象,并指定给存储元素的TreeSet
ComWithLength comWithLength = new ComWithLength();
TreeSet set = new TreeSet<>(comWithLength);
//使用TreeSet在存储字符串的时候自动实现了排序和去重
set.add("java1111111111111");
set.add("java422");
set.add("java2456");
set.add("java523535");
set.add("java2456");
System.out.println(set);
}
}
//1.创建比较器类
class ComWithLength implements Comparator{
@Override
public int compare(Object o1, Object o2) {
//容错处理
if (!(o1 instanceof String)) {
throw new ClassCastException("类型转换异常");
}
if (!(o2 instanceof String)) {
throw new ClassCastException("类型转换异常");
}
//向下转型
String s1 = (String)o1;
String s2 = (String)o2;
//要求按照字符串的长度对字符串进行排序--从短到长,当长度相同的时候,按照字典排序
int num = s1.length()-s2.length();
return num==0?s1.compareTo(s2):num;
}
}