第十章 集合框架 ② 代码
1.Collection接口 遍历元素
package com.yzh7.test2;
import com.sun.corba.se.impl.ior.OldJIDLObjectKeyTemplate;
import java.util.ArrayList;
import java.util.Collection;
/**
* @author: hy
* @create: 2022-07-08 10:27:13
*/
public class Test {
public static void main(String[] args) {
//创建Collection接口
Collection col = new ArrayList();
//存储数据
col.add("abc");
col.add(100);
col.add(1.7);
col.add(true);
System.out.println(col);
//遍历元素
for (Object obj : col){
System.out.println(obj);
}
col.remove("abc");
System.out.println(col);
}
}
2.重写equals方法，实现按内容判断相等性
package com.yzh7.test2;
import java.util.Objects;
/**
* @author: hy
* @create: 2022-07-08 10:55:58
*/
public class Student {
private String name;
private String sex;
private int age;
public Student() {
}
public Student(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
//重写equals方法，实现按内容判断相等性
@Override //s1.equals(s2)
public boolean equals(Object obj) {
System.out.println("=======调用了 student equals========:"+obj);
//1.判断地址是否相等
if(this==obj){
return true;
}
//2.判断目标类型和当前对象的类型是否一致
if (!(obj instanceof Student)){
//类型不一致，直接返回false
return false;
}
//3.做类型转换，比较内容
Student s = (Student) obj;
if(this.name.equals(s.name) && this.sex.equals(s.sex) && this.age==s.age){
return true;
}
return false;
}
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;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
}
3.创建list集合
1.数据有序 2.可以重复 3.有索引
package com.yzh7.test2;
import java.util.ArrayList;
import java.util.List;
/**
* @author: hy
* @create: 2022-07-08 10:55:48
*/
public class Test2 {
public static void main(String[] args) {
//创建list集合
//1.数据有序 2.可以重复 3.有索引
List list = new ArrayList();
list.add("bbb");
list.add("aaa");
list.add("aaa");
list.add(123);
list.add(234.234);
list.add(true);
list.add(new Student("张三","男",20));
//打印输出
System.out.println(list);
//输出长度
System.out.println(list.size());
//输出下标为2的元素
System.out.println(list.get(2));
//根据数值删除数据
//list.remove("bbb");
//System.out.println(list);
//list.remove(234.234);
//System.out.println(list);
//传入整数时，默认按索引删除
//list.remove(new Integer(123));
//list.remove(Integer.valueOf(123));
//System.out.println(list);
//list.remove(new Student("张三","男",20));
//System.out.println(list);
//批量删除
// List list2 = new ArrayList();
// list2.add("bbb");
// list2.add("aaa");
// list2.add(Integer.valueOf(123));
// list.removeAll(list2);
// System.out.println(list);
//System.out.println(list.contains("xxx"));
//集合遍历
//方式1:索引遍历
for (int i=0;i<list.size();i++){
Object o = list.get(i);
System.out.println(o);
}
System.out.println("======================");
//方式2:for each
for(Object o : list){
System.out.println(o);
}
}
}
4. 判断相等性 （用到上方的2）
package com.yzh7.test2;
/**
* @author: hy
* @create: 2022-07-08 11:07:27
*/
public class Test3 {
public static void main(String[] args) {
String s1 = "abc";
String s2 = new String("abc");
//System.out.println(s1==s2);
//System.out.println(s1.equals(s2));
System.out.println("====================");
Student stu1 = new Student("张三","男",20);
Student stu2 = new Student("张三","男",21);
System.out.println(stu1==stu2);
System.out.println(stu1.equals(stu2));
}
}
5.链表:1.查询效率低 2.添加删除效率高
package com.yzh7.test3;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;
/**
* @author: hy
* @create: 2022-07-08 11:51:33
*/
public class Test {
public static void main(String[] args) {
//链表:1.查询效率低 2.添加删除效率高
LinkedList list = new LinkedList();
list.add("aaa");
list.add("ccc");
list.add("ddd");
list.add(100);
list.add(300);
list.add(200);
System.out.println(list);
list.addFirst("xxxx"); //头部添加
list.addLast("yyyy"); //尾部添加
System.out.println(list);
list.add(3,"qqq");
System.out.println(list);
list.removeLast(); //删除尾部
list.removeFirst();//删除头部
System.out.println(list);
System.out.println("=================");
//Vector:多线程环境下安全，性能低。
//ArrayList:多线程环境下不安全，性能高
Vector vector = new Vector();
vector.add("sdfs");
vector.add("asdf");
vector.add(2423);
vector.add(true);
vector.add(null);
System.out.println(vector);
}
}
课前测试 0709
package com.yzh7.test1;
import java.rmi.StubNotFoundException;
import java.util.Objects;
/**
* @author: hy
* @create: 2022-07-09 09:26:15
*/
public class People {
private String name;
private String sex;
public People() {
}
public People(String name, String sex) {
this.name = name;
this.sex = sex;
}
//重写equals
@Override
public boolean equals(Object obj) {
//判断地址
if(this==obj){
return true;
}
//判断类型
if(!(obj instanceof People)){
return false;
}
//判断内容
People p = (People) obj;
if(Objects.equals(this.name,p.name) &&
Objects.equals(this.sex,p.sex)){
return true;
}
return false;
}
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 String toString() {
return "People{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
'}';
}
}
package com.yzh7.test1;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
* @author: hy
* @create: 2022-07-09 09:27:29
*/
public class Test {
public static void main(String[] args) {
//创建List集合
List list = new ArrayList();
//创建输入工具类对象
Scanner scanner = new Scanner(System.in);
while (true){
System.out.println("请输入姓名:");
String name = scanner.next();
System.out.println("请输入性别:");
String sex = scanner.next();
//使用输入的数据创建People对象
People people = new People(name,sex);
//判重:做信息的重复校验
if(list.contains(people)){
System.out.println("该同志信息已经存在....");
continue;
}
//将对象添加到集合中
list.add(people);
System.out.println("是否要继续添加(y/n)?");
String answer = scanner.next();
//如果不继续输入，则退出循环
if("n".equals(answer)){
//退出循环
break;
}
}
System.out.println("录入人员的信息是:");
for (int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-09 09:36:50
*/
public class Test2 {
public static void main(String[] args) {
// People p1 = new People("张三","男");
// People p2 = new People("张三","男");
// System.out.println(p1.equals(p2));
int num = 4;
//int n = num>>1; //==> num/2
int n = num<<1; //num*2
System.out.println(n);
//二进制
//0001 0010 0011 0100 0101
}
}
2.ArrayList
package com.yzh7.test2;
import java.util.ArrayList;
import java.util.Iterator;
/**
* @author: hy
* @create: 2022-07-09 09:45:43
*/
public class Test {
public static void main(String[] args) {
//ArrayList源码:
//1.扩容原理(如何存储数据)
// a.底层存储数据的结构:Object[] 数组
// b.具体的扩容实现:第一次扩容到10,后面的扩容都是1.5倍
//2.各个方法具体实现
//
ArrayList arrayList = new ArrayList();//ArrayList底层是一个Object[] 空数组
arrayList.add("abc1"); //添加数据
arrayList.add("bbb2"); //添加数据
arrayList.add("bbb3"); //添加数据
arrayList.add("bbb4"); //添加数据
arrayList.add("bbb5"); //添加数据
arrayList.add("bbb6"); //添加数据
/*for (int i=arrayList.size()-1;i>=0;i--){
arrayList.remove(i);
}*/
//for Each或迭代器只能用于遍历，不能用于元素的修改和删除
/*for (Object obj : arrayList){
arrayList.remove(obj);
}*/
arrayList.clear();
System.out.println(arrayList);
/*
Object o = arrayList.remove(1);
arrayList.remove("aaa");
arrayList.size();
arrayList.contains();
arrayList.indexOf();
arrayList.clear();
*/
// int[] nums =new int[10];
// System.out.println(nums.length);
// //容量，元素个数
// nums[0]=100;
// nums[1]=200;
// nums[2]=300;
}
}
3.Set 重写HashCode算法 重写equals
package com.yzh7.test3;
import com.yzh7.test1.People;
import java.util.Objects;
/**
* @author: hy
* @create: 2022-07-09 11:12:49
*/
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//重写HashCode算法，返回hash值，通过hash值得到要存储到数组的下标。
//hash值一样的一定存储到同一个数组空间。后面再用equals进行内容比较
@Override
public int hashCode() {
int res = this.name.hashCode()+age;
System.out.println("调用了hashCode:"+res);
return res;
}
//重写equals
@Override
public boolean equals(Object obj) {
System.out.println("调用了equals");
//判断地址
if(this==obj){
return true;
}
//判断类型
if(!(obj instanceof Student)){
return false;
}
//判断内容
Student s= (Student) obj;
if(Objects.equals(this.name,s.name) &&
Objects.equals(this.age,s.age)){
return true;
}
return false;
}
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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.yzh7.test3;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* @author: hy
* @create: 2022-07-09 11:12:06
*/
public class Test {
public static void main(String[] args) {
//Set:1.无序 2.不重复 3.没有下标
Set set = new HashSet();
set.add("bbb");
set.add("bbb");
set.add(true);
set.add(12.234);
set.add("aaa");
set.add("aaa");
set.add(100);
set.add(200);
set.add(new Student("张三",20));
//打印集合内容
//System.out.println(set);
//打印长度
//System.out.println(set.size());
//set无法按照索引获取数据，因为set是无序的没有下标
//删除
//set.remove("aaa");
//System.out.println(set);
//包含某个数据
//System.out.println(set.contains("bbb"));
//是否为空
//System.out.println(set.isEmpty());
//System.out.println("================================");
//遍历set集合
//方式1：for Each
for (Object obj : set){
System.out.println(obj);
}
System.out.println("============================");
//方式2: Iterator迭代器
//通过集合对象的iterator()方法，返回一个Iterator对象，通过这个对象可以遍历集合元素
Iterator it = set.iterator();
//it.hasNext():判断集合是否有数据,返回true/false
//it.next():读取集合中的一个数据
while (it.hasNext()){
Object o = it.next();
System.out.println(o);
}
}
}
package com.yzh7.test3;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
/**
* @author: hy
* @create: 2022-07-09 11:25:48
*/
public class Test2 {
public static void main(String[] args) {
// Student s1 = new Student("张三",20);
// Student s2 = new Student("张三",20);
// System.out.println(s1.equals(s2));
// HashMap hashMap =new HashMap();
// hashMap.put("aaa",1000);
// hashMap.put("bbb",1000);
// System.out.println(hashMap);
// System.out.println("aaaa".hashCode());
// System.out.println("bbbb".hashCode());
// System.out.println("aaaa".hashCode());
// Student s = new Student("张三",10);
// Student s1 = new Student("张三",10);
// Student s2 = new Student("张三",10);
// Student s3 = new Student("张三",10);
// System.out.println(s.hashCode());
// System.out.println(s1.hashCode());
// System.out.println(s2.hashCode());
// System.out.println(s3.hashCode());
Set set = new HashSet();
//1.重写了hashCode 2.重写了equals
set.add(new Student("张三",20));
set.add(new Student("张三",20));
set.add(new Student("张三",20));
set.add(new Student("张三",20));
set.add(new Student("李四",20));
System.out.println(set);
}
}
课前测试 0711
1.定义商品类: 商品名字，价格
2.通过输入的方式创建5个商品
3.将商品添加到Set集合中，要求信息相同的商品不能重复添加
4.使用迭代器遍历商品信息
package com.yzh7.test4;
import java.util.Objects;
/**
* @author: hy
* @create: 2022-07-11 09:20:21
*/
public class Goods {
private String name;
private double price;
public Goods() {
}
public Goods(String name, double price) {
this.name = name;
this.price = price;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Goods goods = (Goods) o;
return Double.compare(goods.price, price) == 0 && Objects.equals(name, goods.name);
}
@Override
public int hashCode() {
return Objects.hash(name, price);
}
//重写hashCode
// @Override
// public int hashCode() {
// return this.name.hashCode()+Double.hashCode(this.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 "Goods{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
package com.yzh7.test4;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
/**
* @author: hy
* @create: 2022-07-11 09:21:16
*/
public class Test {
public static void main(String[] args) {
Goods goods1 = new Goods("aaa",1);
Goods goods2 = new Goods("aaa",1);
//System.out.println(goods1.hashCode());
//System.out.println(goods2.hashCode());
System.out.println(goods1.equals(goods2));
//创建Set集合
Set set = new HashSet();
set.add(goods1);
set.add(goods2);
System.out.println(set);
/*
Scanner scanner = new Scanner(System.in);
//创建Set集合
Set set = new HashSet();
for (int i=1;i<=5;i++){
System.out.println("请输入第"+i+"个商品的名字:");
String goodsName =scanner.next();
System.out.println("请输入第"+i+"个商品的价格:");
double goodsPrice = scanner.nextDouble();
Goods goods = new Goods(goodsName,goodsPrice);
System.out.println(goods.hashCode());
set.add(goods);
}
//遍历set集合
Iterator it = set.iterator();
while (it.hasNext()){
System.out.println(it.next());
}*/
}
}
2.TreeSet
package com.yzh7.test5;
/**
* @author: hy
* @create: 2022-07-11 09:52:58
*/
public class Student implements Comparable{
private String name;
private int age;
public Student() {
}
public Student(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 String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//比较对象大小: 等于0,大于0,小于0
@Override
public int compareTo(Object o) {
//先判断类型是否一致
if(!(o instanceof Student)){
//不进行比较,直接返回特定值
return -1;
}
Student s = (Student) o;
//年龄不相等时，按年龄比
if(this.age>s.age){
return 1;
}else if(this.age<s.age){
return -1;
}else{
//年龄相等时，按姓名比较
return this.name.compareTo(s.name);
}
}
}
package com.yzh7.test5;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
/**
* @author: hy
* @create: 2022-07-11 09:43:13
*/
public class Test {
public static void main(String[] args) {
Set set = new TreeSet();
set.add("b");
set.add("b");
set.add("b");
set.add("c");
set.add("a");
set.add("d");
//同类型才能比较
// set.add(20);
// set.add(10);
System.out.println(set);
}
}
package com.yzh7.test5;
/**
* @author: hy
* @create: 2022-07-11 09:45:46
*/
public class Test2 {
public static void main(String[] args) {
String s1 = "z";
String s2 = "b";
System.out.println(s1.compareTo(s2));
//向上转型
// Comparable c =s1;
// Comparable c2 = s2;
// c.compareTo(c2);
}
}
package com.yzh7.test5;
import java.util.Set;
import java.util.TreeSet;
/**
* @author: hy
* @create: 2022-07-11 09:53:28
*/
public class Test3 {
public static void main(String[] args) {
//Comparable c = new Student("张三",20);
Set set = new TreeSet();
//自定义对象添加到TreeSet，必须实现比较接口，这样TreeSet才能排序
set.add(new Student("张三",18));
set.add(new Student("李四",16));
set.add(new Student("王五",13));
set.add(new Student("赵六",26));
System.out.println(set);
//自定义对象添加到TreeSet，保证有序性，两种做法:
//1.自定义对象实现Comparable接口
//2.自己定义一个比较器对象，实现Comparator接口
}
}
package com.yzh7.test5;
/**
* @author: hy
* @create: 2022-07-11 10:05:39
*/
public class Car {
private String brand;
private int price;
public Car() {
}
public Car(String brand, int price) {
this.brand = brand;
this.price = price;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
@Override
public String toString() {
return "Car{" +
"brand='" + brand + '\'' +
", price=" + price +
'}';
}
}
package com.yzh7.test5;
import java.util.Comparator;
/**
* 自定义比较器，实现特定对象的比较
* @author: hy
* @create: 2022-07-11 10:04:29
*/
public class MyComparator implements Comparator {
@Override
public int compare(Object o1, Object o2) {
//只比较汽车
if(!(o1 instanceof Car)){
return -1;
}
if(!(o2 instanceof Car)){
return -1;
}
Car c1 = (Car)o1;
Car c2 = (Car) o2;
if(c1.getPrice()>c2.getPrice()){
return 1;
}else if(c1.getPrice()<c2.getPrice()){
return -1;
}else{
return c1.getBrand().compareTo(c2.getBrand());
}
}
}
package com.yzh7.test5;
import java.util.Set;
import java.util.TreeSet;
/**
* @author: hy
* @create: 2022-07-11 10:08:54
*/
public class Test4 {
public static void main(String[] args) {
//使用自定义比较器对象进行比较
Set set = new TreeSet(new MyComparator());
set.add(new Car("宝马",200));
set.add(new Car("宝马",200));
set.add(new Car("奔驰",100));
set.add(new Car("法拉利",300));
System.out.println(set);
}
}
3.LinkedHashSet
package com.yzh7.test6;
import java.util.LinkedHashSet;
import java.util.Set;
/**
* @author: hy
* @create: 2022-07-11 10:51:39
*/
public class Test {
public static void main(String[] args) {
Set set = new LinkedHashSet();
set.add("c");
set.add("d");
set.add("a");
set.add("a");
set.add("a");
set.add("b");
set.add(100);
set.add(45);
System.out.println(set);
}
}
4.HashMap
package com.yzh7.test7;
/**
* @author: hy
* @create: 2022-07-11 11:01:44
*/
public class People {
private String name;
private int age;
public People() {
}
public People(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 String toString() {
return "People{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.yzh7.test7;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* @author: hy
* @create: 2022-07-11 11:01:39
*/
public class Test {
public static void main(String[] args) {
Map map = new HashMap();
//存储数据
map.put("aaa",100);
map.put("bbb",200);
map.put("aaa",300);//键重复时，后面的数据覆盖前面的
map.put(20,"xxxx");
map.put("ccc",200);
map.put("张三",new People("张三",20));
System.out.println(map);
System.out.println(map.size());
//根据键获取值
System.out.println(map.get("张三"));
//判断是否为空
System.out.println(map.isEmpty());
//判断是否包含某个键
System.out.println(map.containsKey("aaa"));
//返回Map中，所有键值对数据中，键的集合
System.out.println(map.keySet());
//返回Map中，所有键值对数据中,值的集合
System.out.println(map.values());
System.out.println("======================");
//遍历map
//1.获取键的集合,遍历键
Set keys = map.keySet();
for (Object k : keys){
//2.通过键获取值
System.out.println(k+" --> "+map.get(k));
}
System.out.println("====================");
map.remove("aaa");
System.out.println(map);
map.clear();
System.out.println(map);
}
}
package com.yzh7.test7;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* @author: hy
* @create: 2022-07-11 11:10:50
*/
public class Test2 {
public static void main(String[] args) {
//遍历Map的两种方式
Map map = new HashMap();
//存储数据
map.put("aaa",100);
map.put("bbb",null);
map.put("aaa",300);//键重复时，后面的数据覆盖前面的
map.put(null,"xxxx");
map.put("ccc",200);
map.put("张三",new People("张三",20));
System.out.println(map);
//方式一:遍历键的集合
Set keys = map.keySet();
for (Object k : keys){
System.out.println(k+" ---> "+map.get(k));
}
System.out.println("==================");
//方式二:遍历键值对集合
Set kvSet = map.entrySet();
//遍历键值对对象
for (Object kv : kvSet){
//Map.Entry:Map接口的子接口，表示一个键值对对象
Map.Entry e = (Map.Entry)kv;
System.out.println(e.getKey()+" ==== "+e.getValue());
}
}
}
5.Hashtable
package com.yzh7.test8;
import java.util.Hashtable;
import java.util.Map;
/**
* @author: hy
* @create: 2022-07-11 11:44:59
*/
public class Test {
public static void main(String[] args) {
//Hashtable键和值都不能为null，线程安全，效率低
Map tab = new Hashtable();
tab.put("aaa",100);
tab.put("bbb",100);
tab.put("aaa",200);
tab.put("ccc",300);
tab.put("ddd",500);
System.out.println(tab);
}
}
6.泛型集合
package com.yzh7.test9;
/**
* @author: hy
* @create: 2022-07-11 11:01:44
*/
public class People {
private String name;
private int age;
public People() {
}
public People(String name, int age) {
this.name = name;
this.age = age;
}
//自我介绍
public void introduce(){
System.out.println(this.name+" "+this.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 "People{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.yzh7.test9;
import java.util.ArrayList;
import java.util.List;
/**
* @author: hy
* @create: 2022-07-11 11:47:36
*/
public class Test {
public static void main(String[] args) {
//泛型集合
//泛型: 限定类型
List<People> list = new ArrayList<People>();
//list.add("abc"); //添加的数据不是People直接报错
//list.add(100); //添加的数据不是People直接报错
list.add(new People("张三",10));
list.add(new People("李四",20));
//遍历
for(int i=0;i<list.size();i++){
People p = list.get(i);
p.introduce();
}
System.out.println("=============");
for(People p : list){
p.introduce();
}
//不使用泛型集合，可以随意添加数据，但是使用数据比较麻烦
// List list = new ArrayList();
// list.add("abc");
// list.add(200);
// list.add(23.234);
// list.add(new People("张三",20));
// list.add(new People("李四",18));
//
// for(int i=0;i<list.size();i++){
// Object obj = list.get(i);
// if(obj instanceof People){
// People p = (People) obj;
// p.introduce();
// }
// //System.out.println(list.get(i));
// }
}
}
package com.yzh7.test9;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* @author: hy
* @create: 2022-07-11 11:53:56
*/
public class Test2 {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
//set.add(100);
set.add("aaa");
set.add("bbb");
set.add("ccc");
set.add("ddd");
for (String s: set){
System.out.println(s);
}
System.out.println("==============");
Iterator<String> it = set.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
}
package com.yzh7.test9;
import java.util.*;
/**
* @author: hy
* @create: 2022-07-11 11:55:28
*/
public class Test3 {
public static void main(String[] args) {
//泛型的类型必须是引用类型或对象类型
Map<String,People> map = new HashMap<>();
map.put("张三",new People("张三",20));
map.put("李四",new People("李四",10));
map.put("xxxx",new People("王五",23));
Set<String> keys = map.keySet();
for(String s : keys ){
System.out.println(s+" "+map.get(s));
}
//存储一个表的若干行数据
List<Map<String,Object>> list = new ArrayList<>();
/*
Goods 商品: 名字，分类
List<Goods>
方便面 食品
火腿肠 食品
冰红茶 饮品
奶茶 饮品
洗衣粉 日用品
Map<String,String>
食品: 方便面，火腿肠
饮品: 冰红茶,奶茶
日用品: 洗衣粉
*/
}
}
List和Map数据转存 （作业3） 0712
package com.yzh70712.zuoye2;
/**
* @author: XYT
* @create-date: 2022/7/12 16:07
*/
public class ShangPin {
private String leibie;
private String name;
public ShangPin() {
}
public ShangPin(String leibie, String name) {
this.leibie = leibie;
this.name = name;
}
public String getLeibie() {
return leibie;
}
public void setLeibie(String leibie) {
this.leibie = leibie;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "ShangPin{" +
"leibie='" + leibie + '\'' +
", name='" + name + '\'' +
'}';
}
}
package com.yzh70712.zuoye2;
import com.yzh70701.Shangpin;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author: XYT
* @create-date: 2022/7/12 16:09
*/
public class TestS {
public static void main(String[] args) {
ShangPin shangpin1=new ShangPin("饮料","冰红茶");
ShangPin shangpin2=new ShangPin("食品","方便面");
ShangPin shangpin3=new ShangPin("日用品","洗衣粉");
ShangPin shangpin4=new ShangPin("饮料","咖啡");
ShangPin shangpin5=new ShangPin("食品","火腿肠");
List<ShangPin> list=new ArrayList<>();
list.add(shangpin1);
list.add(shangpin2);
list.add(shangpin3);
list.add(shangpin4);
list.add(shangpin5);
for(ShangPin sp:list){ //for-each
System.out.println(sp);
}
Map<String,String> map=new HashMap<>(); //Map中存放的是键值对
for(int i=0;i<list.size();i++){
ShangPin spi=list.get(i);
if(map.containsKey(spi.getLeibie())){ //map.containsKey(spi.getLeibie()) 判断map中是否存在键（类别）
String oldName=map.get(spi.getLeibie()); //获得map中已存在的键（类别）所对应的值（名称） 赋值给oldName
String newName=oldName+" "+spi.getName(); //将oldName与新添加的已存在的键（类别）所对应的值（名称）进行拼接
map.put(spi.getLeibie(),newName);
}else{
map.put(spi.getLeibie(),spi.getName()); //将键（类别）和值（名称）存入到map键值对集中
}
}
for(String key:map.keySet()){ //for-each //map.keySet() map中的键集
System.out.println(key+"--->"+map.get(key)); //map.get(key) 通过键--键值对-->值
}
}
}
People–>ArrayList–>HashSet–>HashMap（作业2）
将Person对象放入ArrayList中，必须有重复的对象，转换到HashSet中（不能有重复的对象），之后将集合中的Person对象导入到HashMap，key使用Person的名字，并遍历并展示出来。
package com.yzh70712.zuoye2;
import java.util.Objects;
/**
* @author: XYT
* @create-date: 2022/7/12 20:22
*/
public class People {
private String name;
private int age;
public People(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) { // Set set=new HashSet();去除重复时需要在类中定义equals（） and hashCode()方法（自动生成）
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
People people = (People) o;
return age == people.age && Objects.equals(name, people.name);
}
@Override
public int hashCode() {
return Objects.hash(name, 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 "People{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.yzh70712.zuoye2;
import java.util.*;
/**
* @author: XYT
* @create-date: 2022/7/12 20:24
*/
public class Test1 {
public static void main(String[] args) {
People people=new People("zhangsan",50);
People people1=new People("zhangsan",50);
People people2=new People("lisi",69);
People people3=new People("wangwu",78);
List list=new ArrayList();
list.add(people);
list.add(people1);
list.add(people2);
list.add(people3);
for(Object people4:list){ //for-each 变量属性为Object
System.out.println(people4);
}
System.out.println("++++++++++++++++++++++");
Set set=new HashSet();
//遍历list集合
for (int i = 0; i < list.size(); i++) {
//获取list中的People对象数据
People people5= (People) list.get(i); //注意：这里有强制转化
//添加到set
set.add(people5);
}
//第一种方式：遍历set集合
for(Object people6:set){ //for-each 变量属性为Object
System.out.println(people6);
}
System.out.println("=============================");
Map map=new HashMap();
/*//遍历set集合 (错误！不能遍历set,因为HashMap()中的数据是无序的，只能用迭代器Iterator)
for (int i = 0; i < set.size(); i++) {
People people7=()
}*/
//第二种方式：遍历set集合
Iterator it=set.iterator();
while(it.hasNext()){
Object o=it.next();
People p=(People)o; //强转
map.put(p.getName(),p.getAge());
}
//遍历map
for(Object m: map.keySet()){
System.out.println(m);
}
//map.put(); //.put(key,value)
}
}
2.自定义单链表的实现
package com.test2;
/**
* 链表节点
* @author: hy
* @create: 2022-07-12 09:45:22
*/
public class Node {
//数据
private Object data;
//下一个节点对象
private Node next;
public Node() {
}
public Node(Object data) {
this.data = data;
}
public Node(Object data, Node next) {
this.data = data;
this.next = next;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
@Override
public String toString() {
return "Node{" +
"data=" + data +
", next=" + next +
'}';
}
}
package com.test2;
/**
* @author: hy
* @create: 2022-07-12 09:47:23
*/
public class MyLink {
//定义头结点:1.不存储数据 2.初始的时候next为空
private Node head;
//链表的元素个数
private int size;
public MyLink(){
//初始化头结点
this.head=new Node();
}
//添加数据
public void add(Object data){
//1.根据要添加的数据创建新节点
Node newNode = new Node(data);
//2.查找链表中的最后一个节点
// 特征:next属性为空
Node h = this.head;
while (h.getNext()!=null){
//获取下一个节点
h = h.getNext();
}
//循环结束之后，h就指向最后一个节点
//3.将新节点挂到最后一个节点上
// (让next属性指向新节点)
h.setNext(newNode);
//4.长度加1
this.size++;
}
//遍历链表
public void display(){
//获取第一个节点
Node n = head.getNext();
while (n!=null){
System.out.println(n.getData());
//获取下一个节点
n = n.getNext();
}
}
//修改数据
//删除数据
//插入数据
//返回长度
public Node getHead() {
return head;
}
public void setHead(Node head) {
this.head = head;
}
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
}
package com.test2;
/**
* @author: hy
* @create: 2022-07-12 10:04:28
*/
public class Test {
public static void main(String[] args) {
//创建链表
MyLink myLink = new MyLink();
myLink.add("aaa");
myLink.add("bbb");
myLink.add("ccc");
myLink.add("ddd");
myLink.display();
System.out.println(myLink.getSize());
}
}
3.HashMap
package com.test3;
import java.util.HashMap;
/**
* @author: hy
* @create: 2022-07-12 10:13:20
*/
public class Test {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("aaa",100);
}
}
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/118123.html
