集合简介
关系示例图
Collection接口实现类的特点
Collection接口常用方法
Collection接口遍历元素方式：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
*/public class Main {
public static void main(String[] args) {
Collection List=new ArrayList();
List.add(new Book("小米","雷军",28.9));
List.add(new Book("小米","雷军",28.9));
List.add(new Book("小米","雷军",28.9));
List.add(new Book("小米","雷军",28.9));
Iterator iterator=List.iterator();//返回List的迭代器（Iterator）
while (iterator.hasNext())//判断返迭代器中下一个是元素还是抛出异常，是元素返回true
{
Object object=iterator.next();//返回下一个元素，返回类型是Object
System.out.println(object);
}
//增加for循环，底层仍然是迭代器
for (Object book:List)
System.out.println(book);
}
}
class Book{
private String name;
private String author;
private double price;
public Book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
List接口常用方法
package com.List;
import java.util.ArrayList;
import java.util.List;
/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
*/public class test {
public static void main(String[] args) {
List list= new ArrayList();
list.add("续爱");
list.add("小美");
System.out.println(list);//[续爱, 小美]
System.out.println(list.get(1));//小美可获取对应下标序列的数据
//1表示加入的数据插入的位置下标
list.add(1,"续期");
System.out.println(list);//[续爱, 续期, 小美]
List list1=new ArrayList();
list1.add("小怒");
//在指定位置插入另一个集合
list.addAll(0,list1);
System.out.println(list);//[小怒, 续爱, 续期, 小美]
System.out.println(list.lastIndexOf("小怒"));//最后一次出现的位置（下标）
System.out.println(list.indexOf("小怒"));//第一次出现该数据的位置（下标）
list.remove(0);//移除指定下标的数据
System.out.println(list);//[续爱, 续期, 小美]
list.set(2,"梦里");//指定位置的数据替换成我们现在输入的数据
System.out.println(list);//[续爱, 续期, 梦里]
System.out.println(list.subList(0,2));//[续爱, 续期]从0号下标的数据到2号下标前一位数据。
}
}
例题：
package com.List.test01;
import java.util.ArrayList;
import java.util.List;
/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
ListExercise.java
●添加10个以上的元素(比如String"hello”),在2号位插入一个元素“韩顺平教
育”,获得第5个元素,删除第6个元素,修改第7个元素,在使用迭代器遍历集
合,要求:使用List的实现类ArrayList完成。
*/public class test01 {
public static void main(String[] args) {
List list= new ArrayList();
list.add("美女");
list.add("帅哥");
list.add("小胡");
list.add("小美");
list.add("东东");
list.add("美女");
list.add("帅哥");
list.add("小胡");
list.add("小美");
list.add("东东");
list.add(1,"韩顺平");
list.get(4);
list.remove(5);
list.set(6,"小敏");
for (Object o :list) {
System.out.print(o+" ");
}
}
}
List三种遍历方法
package com.List.test02;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
使用List的实现类添加三本图书,并遍历,打印如下效果
名称:xx
名称:xx
名称:xx
要求
1)按价格排序,从低到高(使用冒泡法)
2)要求使用ArrayList、LinkedList 和 Vector三种集合实现
*/public class test02 {
public static void main(String[] args) {
List list= new ArrayList();
list.add(new Book("小米","雷军",1999));
list.add(new Book("泪目","设计",1234));
list.add(new Book("箱子哦","啊上档次",120));
manner_(list);
}
static void manner_(List list)
{
for(int i=0;i<list.size()-1;i++)
{
for(int j=0;j<list.size()-1-i;j++)
{
Book o=(Book)list.get(j);
Book o1=(Book)list.get(j+1);
if (o.getPrice()>o1.getPrice())
{
list.set(j,o1);
list.set(j+1,o);
}
}
}
Iterator iterator=list.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
}
}
class Book{
private String name;
private String author;
double price;
public Book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
ArrayList注意事项
ArrayList源码
调用ArrayList无参构造器的源码代表此时的elementData为默认的一个elemenData深入可发现目前就是空的一个数组
ensuCapacityInternal（）确认容量是否够，然后再赋值
ensuCapacityInternal（）方法内容是先判断elementData是否空数组，是就给你添个扩容值。扩容值从
与minCapacity中选大的那个，而此时
默认值是10，minCaoacity是我们上面那步传进来的1，所以再调用ArrayList无参构造器时，第一次添加给的容积为10，确定了扩容值后再来到该方法确定是否真的要扩容
modCound++表示当前集合修改的次数，再往下的判断表示，要扩容的值是否能被当前有的容积容纳，当前的容积是否够，如果大于0代表不够，开始扩容
来到扩容的方法，
表示，新的容积等于当前的容积加上当前的容积除以2（向右移一位）也就是扩成当前的1.5倍，再来判断，新的是否小于之前需要的容量，小于那么就让新的容量变成需要的容量
然后开始扩容数组，
使用copyof（）来完成这个方法是因为他不会覆盖原有的值进行扩容
要去掉该选项，不然Debug会阉割数据
走有参构造器的ArrayList，创建一个指定大小的数组
Vector介绍
Vector与ArrayList比较
使用无参构造器，底层默认给你十个容量
到加数据的方法add，modCount也是记录修改的次数。然后ensureCapcityHelper是确定需要的空间和已有的空间匹不匹配。如果大于零则不够需要扩容
判断capacityIncrement是否大于0.如果不大于0则就是oldCapacity加oldCapacity为当前容量，也就是所说的按2倍扩容。
有参构造器
LinkedList介绍
底层解析
链表调用无参构造器删除的是第一个节点
ArrayList与LinkedList比较
Set接口
Set接口常用方法
HashSet介绍
底层机制介绍
占位作用
得到传进来的数的hash值，这个值决定着数存放的位置
package com.test01;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
定义一个Employee类,该类包含:private成员属性name,age要求:
1.创建3个Employee放入HashSet中
2.当name和age的值相同时,认为是相同员工,不能添加到HashSet集合中
*/public class test01 {
public static void main(String[] args) {
HashSet set = new HashSet();
System.out.println(set.add(new Employee("小米",18)));
System.out.println(set.add(new Employee("小米",18)));
}
}
class Employee{
private String name;
private int age;
public Employee(String name, int age) {
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 o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return age == employee.age && Objects.equals(name, employee.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
package com.test02;
import java.util.HashSet;
import java.util.Objects;
/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
定义一个Employee类,该类包含:private成员属性name,sal,birthday(MyDate类
型),其中birthday为MyDate类型(属性包括:year,month,day),要求:
1.创建3个Employee放入HashSet中
2.当name和birthday的值相同时,认为是相同员工,不能添加到HashSet集合中
*/public class test02 {
public static void main(String[] args) {
//Employee employee = new Employee("小美", "女", new Employee.myDate(2003, 1, 1));
HashSet set = new HashSet();
System.out.println(set.add(new Employee("小美", "女", new Employee.myDate(2003, 1, 1))));
System.out.println(set.add(new Employee("小美", "女", new Employee.myDate(2003, 1, 1))));
}
}
class Employee{
private String name;
private String sex;
myDate birthday;
static class myDate{
private int year;
private int month;
private int day;
public myDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
myDate myDate = (myDate) o;
return year == myDate.year && month == myDate.month && day == myDate.day;
}
@Override
public int hashCode() {
return Objects.hash(year, month, day);
}
}
public Employee(String name, String sex, myDate birthday) {
this.name = name;
this.sex = sex;
this.birthday = birthday;
}
public Employee(String name, String sex) {
this.name = name;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return Objects.equals(name, employee.name) && Objects.equals(sex, employee.sex) && Objects.equals(birthday, employee.birthday);
}
@Override
public int hashCode() {
return Objects.hash(name, sex, birthday);
}
}
TreeSet解析
解析：
TreeSet底层是TreeMap，
使用add（）方法添加数据时，使用m调用了方法put（）
将需要传入的数据传入方法p）中，以及
，
为支持映射的对象关联的虚拟值。
进入put（K key, V value）方法后，又调用了，put（K key, V value，replaceOld），值得一提的是，此时的key为传入的值，value为，
再然后进入到put（K key, V value，replld）方法，
创建一个
类型的t用来指向前面创建得同类型的root，root默认值为null所以此时，t也为null，所以可以进入下面的判断语句，该判断语句内调用了方法
进入该方法先是将传入的key传入
中，传入第一个数据进入该方法其实是为了判断传入的是否为null值
此时的key的值都为传入的数据“ab”，进入该方法内，我们需要判断comparator是否为null，注该变量是初始值是随机生成的，每次都不太一样，但尽管如此，也都不为null，
所以在该方法就需要返回
这部分的结果，因为我们在之前创建Comparator对象时重写了Comparator的compare（）方法，所以这时调用的就是重写的这个方法进行比较，传入的值
重写的方法调用了该方法进行比较，比较方法是拿到字符串底层的数组value，然后将v1和v2数组指向需要比较的两个字符串的ASCII值，注意
JDK9之后由byte类型的数组来存储String，维护了一个属性coder，它是一个编码格式的标识，使用LATIN1还是UTF-16，这个是在String生成的时候自动的，如果字符串中都是能用LATIN1就能表示的就是0，否则就是UTF-16.显然我们得例子这次都可以使用LATIN1，所以c判断为真，
进入
中
该方法拿到两个数组的长度，然后又调用了
这个方法首先调用Math类的min方法拿到两个数组长度中较小的值，然后作为遍历的结束因素，然后进入for循环，开始逐个数据逐个数据比较，如果，两个数组当前的数据不相同，则进入判断返回两个数据的ASCII值的差数，如果知道遍历结束都没有进入if判断，则直接返回两个数组的长度差
经过层层调用比较又回到了这，
新建一个Entry对象，并且将我们传入的值key和value传入新建的这个对象，此时这个对象里的key为“ab”，value的值为，parent的值为null。
然后将为null的root指向他，此时，完成了数据的存放，所以记录数据个数的size赋值为1，然后记录修改次数的modCount也需要++，接着回到了这进行下一步直接返回null
一路返回到这，可以看出来，这里进行了一个判断，因为返回的是null所以为真，所以最终会返回true，那么代表 System.out.println(treeSet.add("ab"));结果会打印出true。
此时第一个数据才算真的装入完毕。
当我们要接着装入值时，前面步骤一致，来到这才有所不同，
通过第一个数据的加入可知，root不再是null。所以t的不是null，那么将不再进入第一个判断语句，
接着往下走，我们可知Comparator的值不是为null是有默认值的，所以，将进入第二个判断语句，
将新建的parent变量指向了我们得t，然后再讲t指向的地址中的key的值与刚传入的key进行比较，之前有分析过比较的方式是最终会返回不同字母时的ASCII值的差或者长度差，因为我们这次传入的是cd，上次是ab，所以这次返回的是2，那么cmp就为2，2是大于0的所以进入
这个判断，将t指向t.right,因为从未有过关于t.right的操作并且right默认值是null，所以目前t也为null，所以将退出此循环，来到该方法，将我们本次传入的数据传入新建的entry对象中，然后因为传入的cmp<0是小于0所以addToleft为false则进入else中，将传入的parent也就是原本指向上一个传入的数据的right指向刚传入的数据
为红黑树的设计暂时不研究，然后就是记录数据的size++，记录修改次数的modCount++。由上可得知，大的成为右节点，小的成为他的左节点
LinkHashSet介绍
底层介绍
package com.test02;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Objects;
/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
Car类(属性:name,price),如果name和price一样,
则认为是相同元素,就不能添加。
*/public class test03 {
public static void main(String[] args) {
LinkedHashSet linkedHashSet = new LinkedHashSet();
System.out.println(linkedHashSet.add(new Car("小牧",1233)));
System.out.println(linkedHashSet.add(new Car("小牧",1233)));
}
}
class Car{
private String name;
private double price;
public Car(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Car car = (Car) o;
return Double.compare(car.price, price) == 0 && Objects.equals(name, car.name);
}
@Override
public int hashCode() {
return Objects.hash(name, price);
}
}
Map接口介绍及常用方法
Map体系继承图
常用方法
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
使用HashMap添加3个员工对象,要求
键:员工id
值:员工对象
并遍历显示工资>18000的员工(遍历方式最少两种)
员工类:姓名、工资、员工id
*/public class test01 {
public static void main(String[] args) {
Map map = new HashMap();
//Employee employee = new Employee(12, "小美", 12340);
// Employee employee1 = new Employee(13, "亚美", 12240);
// Employee employee2 = new Employee(14, "猪猪", 12349);
map.put(12,new Employee(12, "小美", 12340));
map.put(14,new Employee(14, "猪猪", 123499));
map.put(15, new Employee(15, "猪猪", 12349));
Set set = map.entrySet();
for (Object o :set)//将set逐个给了o，
{
Map.Entry m=(Map.Entry)o;//因为具体的key，value的值再Map.Entry里，相应拿到就需要强转
Employee e=(Employee) m.getValue();//因为要判断工资，所以为了拿到工资，我们需要拿到value部分并强转成Employee类
if (e.getSalary()>18000)//拿到并判断
{
System.out.println(m.getValue());}//使用getValue方法打印相应数据
}
Set set1 = map.entrySet();
Iterator iterator=set.iterator();
while (iterator.hasNext())
{
Map.Entry m=(Map.Entry) iterator.next();
Employee n=(Employee)m.getValue();
if (n.getSalary()>18000)
System.out.println(m.getValue());
}
Set keySet = map.keySet();//通过方法keySet（）将Map中所有的key值放入keySet中
for (Object o :keySet) {
Employee e=(Employee) map.get(o);//通过get（key）方法拿到key对应的value，强转成Employee
if (e.getSalary()>18000)
System.out.println(o+" "+map.get(o));
}
}
}
class Employee{
private int id;
private String name;
private double salary;
public Employee(int id, String name, double salary) {
this.id = id;
this.name = name;
this.salary = salary;
}
public Employee(int id) {
this.id = id;
}
public Employee(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Employee{" +
"id=" + id +
", name='" + name + '\'' +
", salary=" + salary +
'}';
}
}
HashMap底层解析
把Node转为entry类型，然后放到entryset里，不过只是指向，目的是方便遍历，因为里面有getvalue和getkey方法
将数据传传入，hash（）方法计算hash值的，由此可见传入的是key，所以key的数据对hash值有直接影响，然后进入putVal（）方法
为true表示不改值和
为false表示为创建模式，此时前者为false后者为true，该判断中，注意，若是第一次放入数据则，table初始就为null，tab为刚新建的，通过赋值过程，tab目前也为null，则开始调用
方法，进行扩容，然后再将扩容好的数组让tab指向，此时tab不再为null，n接收此时扩容好的tab的数组长度，
扩容细节介绍
先创建一个一个数组oldTab指向当前的table数组，然后再来确定oldCap的值，如果oldTab为null则oldCap就为0否则就为oldTab数组的长度，因为首次table为null，所以oldCap就为0，可见oldCap存放的是数组长度
由上可得threshold默认值为0，则初次时oldThr也为0，再进行到下一步的判断，由于一开始，oldCap为0则不进入次if，又因为oldThr也为0则也不进入else if（）所以会直接到达else
为默认初始容量，值为16，所以此时的newC16，而
为加载因子，初始值为0.75，用于提前为扩容考量的，当使用的空间到达用这个数计算出的值就会开始扩容，而不是等到到达当前所拥有的空间的极限才开始扩容，比如此时的newThr为16*0.75=12，则空间占用到12则开始实施扩容。
接着往下走，判断newThr是否为0，此时newThr为12，所以不进入此if
直接来到该步骤，将刚刚计算的临界值付给threshold，此时threshold不再为0而为12，然后新建一个数组容量为newCap（16）的数组newTab
由于第一次存入数据，oldTab还是null，所以不执行则语句直接返回刚刚新建的数组
接收到新建的数组后将tab指向返回的数组，然后将其长度赋给n此时n的值为16
然后再来判断
tab的这个位置是否存有数据，如果没有，则将刚刚传入的数据放入该位置，并且让p指向该数据
如果有了则判断现在传进来的hash值跟p指向的数据的hash值是否一样，传进来的key值是否和p指向的数据是否一样或者传进来的key是否为null且传入的key与p指向的key是否相同（使用equals判断就要看程序员是否重写equals了，具体判定是哪方面的相同全看equals方法的写法），之所以进行这样的判断是因为，hash值的多少与key的值密不可分（之前计算hash值时传入key参与计算了）。如果此判断为真，则将创建得e指向p，所以现在e也指向了p所指向的数据，
通过以上步骤则来到该判断，因为e指向与p同样的地址且地址是有存放数据的则e不可能为null，所以进入此判断语句，
表示当前e指向的地址的value值，将其赋给oldValue，然后来到判断，因为
原本是false，通过！符号就为true了，则进入该判断语句，通过
将传入的value赋给e当前指向的地址所存放的value。从而改变value的值，返回原value值。
倘若顺利进行到这一步，则下一步
赋完数据，直接来到，这
表示记录修改次数，
这个size数值个数的计算，判断当前数据是否大于设置的临界值如果大于则扩容，若是第一次数据加入则为12，不大于则进行下一步返回null
另外此方法还未写所以目前来说调用也还无意义
l
HashMap扩容解析
HashMap小结
HashTable介绍
关系图
HashMap和Hashtable对比
Properties介绍
示意图
总结各类型的选择
示例：
import java.util.*;
/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
*/public class test02 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("tom");
list.add("nice");
list.add("io");
list.add("der");
Collections.reverse(list);
System.out.println("翻转顺序后"+list);//翻转顺序后[der, io, nice, tom]
Collections.shuffle(list);
System.out.println("随机排序后"+list);//随机排序后[tom, nice, der, io]，每运行一次结果都不同
Collections.sort(list);
System.out.println("根据元素进行升序排序"+list);//根据元素进行升序排序[der, io, nice, tom]
Collections.sort(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
// return( (String)o1).compareTo((String) o2);//自行设计排序的比较方法这时字母大小升序排
return ( (String)o1).length()-((String)o2).length();//这是字符串长度升序排
}
});
System.out.println("自定义排序比较方法"+list);
Collections.swap(list,0,3);
System.out.println("下标为0位与下标为三位数据进行交换结果为"+list);//第0位与第三位数据进行交换结果为[nice, der, tom, io]
System.out.println("返回出最大的数据"+Collections.max(list)); //返回出最大的数据tom，同样可以自定义比较方法来得到最大的值
System.out.println("返回最长的数据"+Collections.max(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ( (String)o1).length()-((String)o2).length();
}
}));//返回最长的数据nice
System.out.println("返回出最小的数据"+Collections.min(list)); //返回出最小的数据der同样可以自定义比较方法来得到最大的值
System.out.println("返回最短的数据"+Collections.min(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ( (String)o1).length()-((String)o2).length();
}
}));//返回最短的数据io
System.out.println("返回指定集合中指定的值在其中出现的次数"+Collections.frequency(list,"io"));//返回指定集合中指定的值在其中出现的次数1
List list1 = new ArrayList();//必须要让背copy的集合大小不大于copy进去的集合，
// 所以我们就先让新的集合容量跟被copy的一样，然后再实验copy（）方法
for(int i=0;i<list.size();i++)
{
list1.add(" ");
}
Collections.copy(list1,list);
System.out.println("copylist集合的值后的list1的值为："+list1);
//copylist集合的值后的list1的值为：[nice, der, tom, io]
Collections.replaceAll(list,"tom","谭娜");
System.out.println("替换后"+list);//替换后[nice, der, 谭娜, io]
}
}
例题：
package test05;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
按要求实现:
(1)封装一个新闻类,包含标题和内容属性,提供get、set方法,重写toString方法,打印对象
时只打印标题;
·(2)只提供一个带参数的构造器,实例化对象时,只初始化标题;并且实例化两个对象:
新闻一:新冠确诊病例超千万,数百万印度教信徒赴恒河“圣浴”引民众担忧
新闻二:男子突然想起2个月前钓的鱼还在网兜里,捞起一看赶紧放生
(3)将新闻对象添加到ArrayList集合中,并且进行倒序遍历;
(4)在遍历集合过程中,对新闻标题进行处理,超过15字的只保留前15个,然后在后边加“.”
(5)在控制台打印遍历出经过处理的新闻标题;
*/public class Test01 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new News("新冠确诊病例超千万,数百万印度教信徒赴恒河“圣浴”引民众担忧"));
list.add(new News("男子突然想起2个月前钓的鱼还在网兜里,捞起一看赶紧放生"));
Collections.reverse(list);
for (Object o :list) {
News news=(News) o;
System.out.println(Process(news.getTitle()));
}
}
public static String Process(String st)
{
if (st==null)
return null;
else if (st.length()>15)
return st.substring(0,15)+"...";
else
return st;
}
}
class News{
private String title;
public News(String title) {
this.title = title;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
@Override
public String toString() {
return "News{" +
"title='" + title + '\'' +
'}';
}
}
package test05;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
使用ArrayList 完成对 对象 Car {name,price}的各种操作
1.add:添加单个元素
2.remove:删除指定元素
3.contains:查找元素是否存在
4.size:获取元素个数
5.isEmpty:判断是否为空
6.clear:清空
7.addAll:添加多个元素
8.containsAll:查找多个元素是否都存在
9.removeAll:删除多个元素
使用增强for和 迭代器来遍历所有的car,需要重写Car的toString方法
Car car=new Car(“宝马”,400000);
Car car2=new Car("宾利”,5000000);
*/public class Test02 {
public static void main(String[] args) {
List list = new ArrayList();
Car car=new Car("宝马",400000);
Car car2=new Car("宾利",5000000);
list.add(car);
list.add(car2);
list.remove(0);
System.out.println(list);
System.out.println(list.contains(car));
System.out.println(list.size());
System.out.println(list.isEmpty());
// list.clear();
System.out.println(list);
List list1 = new ArrayList();
list1.addAll(list);
System.out.println(list1);
System.out.println(list1.containsAll(list));
list1.removeAll(list);
System.out.println(list1);
for(Object o:list)
{
System.out.println(o);
}
Iterator iterator=list.iterator();
while (iterator.hasNext())
{
Object next=iterator.next();
System.out.println(next);
}
}
}
class Car{
private String name;
double price;
public Car(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
package test05;
import javax.swing.text.html.HTMLDocument;
import java.security.KeyStore;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
按要求完成下列任务
1)使用HashMap类实例化一个Map类型的对象m,键(String)和值(int)分别用于存储员
jack-650元;tom-1200元;smith-2900元;
工的姓名和工资,存入数据如下:
2)将jack的工资更改为2600元
3)为所有员工工资加薪100元;
4)遍历集合中所有的员工
5)遍历集合中所有的工资
*/public class Test03 {
public static void main(String[] args) {
Map map = new HashMap();
map.put(1,new employee("jack",650));
map.put(2,new employee("tom",1200));
map.put(3,new employee("smith",2900));
Set set=map.entrySet();
for (Object o :set) {
Map.Entry e=(Map.Entry)o;
employee p=(employee) e.getValue();
if (p.getName().compareTo("jack")==0)
{
p.setSalary(2600.0);
}
else
p.setSalary(p.getSalary()+100);
System.out.println(p.getName());
}
Iterator iterator=set.iterator();
while (iterator.hasNext()) {
Map.Entry y=(Map.Entry)iterator.next();
employee m=(employee) y.getValue();
System.out.println(m.getSalary());
}
}
}
class employee{
private String name;
double salary;
public employee(String name, double salary) {
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
因为在此改了p1的内容，所以这个时候的p1跟最开始的那个p1的hash值是不一样的，所以说这个时候移除p1是无法移除存在集合里的，而在此加入的数据，虽然具体数据跟p1现在的数据是一样的，但是存放位置是要用hash值来判断的，最开始存p1hash值是以“AA”来计算的，所以此时这个以cc来计算是会在不同的位置，因此可存放，
因为这次存的数据与最开始的数据p1是一样的所以hash值也是一样的，那么位置就在同一个位置。但是p1后面的内容被改写了，那么他们就会存入在p1值的链表后面
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
