16.list集合,增强for,迭代器,泛型，set集合，map集合,斗地主，HashSet集合，linkedHashSet集合，TreeSet集合,Collection集合,ArrayList集合

最新推荐文章于 2023-01-10 15:04:49 发布

胡启行

最新推荐文章于 2023-01-10 15:04:49 发布

阅读量106

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/weixin_42605384/article/details/115279611

版权

Java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

public class Student {
	public String name;
	public int age;

public Student() {
}

public Student(String name, int age) {
	  this.name = name;
	  this.age = age;
}

@Override
public String toString() {
	  return "Student{" +
       	"name='" + name + '\'' +
        ", age=" + age +
	          		'}';
	}
}

public class TestDemo4  {
public static void main(String[] args) {
	  //1.创建list集合对象
	  List list1 = new ArrayList();
	  //2.创建Student对象
	  Student stu1 = new Student("乔峰",41);
	  Student stu2 = new Student("乔峰",41);
	  Student stu3 = new Student("段誉",46);
	  Student stu4 = new Student("虚竹",35);
	  //3.将对象添加到集合中
	  list1.add(stu1);
	  list1.add(stu2);
	  list1.add(stu3);
	  list1.add(stu4);
	  System.out.println(list1);  
  /**
  输出结果  [Student{name='乔峰', age=41}, Student{name='乔峰', age=41}, Student{name='段誉', age=46}, Student{name='虚竹', age=35}]
  */

//4.输出索引为2的元素对象
Object m = list1.get(2);
System.out.println(m);  //输出 Student{name='段誉', age=46}

//5.普通的for遍历list集合
for (int i = 0; i < list1.size(); i++) {
	Object m1 = list1.get(i);
	System.out.println(m1);
/**
* 输出结果：
* Student{name='乔峰', age=41}
* Student{name='乔峰', age=41}
* Student{name='段誉', age=46}
* Student{name='虚竹', age=35}
*/
}

//6.增强for遍历list集合，快捷键 iter
for (Object m1 : list1) {
	System.out.println(m1);
}
/**
* 输出结果：
* Student{name='乔峰', age=41}
* Student{name='乔峰', age=41}
* Student{name='段誉', age=46}
* Student{name='虚竹', age=35}
*/

//7.迭代器是变脸Collections集合的通用方式，不但可以遍历还可以同时进行增加或删除操作,对于list集合遍历的同时也可以增加删除操作，独有的
//创建迭代器对象
Iterator it = list1.iterator();
while (it.hasNext()){ //如果迭代器中有元素，就一直迭代
	Object s = it.next();  //获取元素
	//String s = (String)it.next(); 有需要的要强制转换成字符串格式，在这里不能转换，会报错
	System.out.println(s);
}
/** 输出结果：
* Student{name='乔峰', age=41}
* Student{name='乔峰', age=41}
* Student{name='段誉', age=46}
* Student{name='虚竹', age=35}
*/

//7.1迭代器遍历的同时增加元素java
List list = new ArrayList();
	list.add("a");
	list.add("b");
	list.add("c");
	Iterator lit = list.iterator();
while (lit.hasNext()) { //如果迭代器中有元素，就一直迭代
	String s = (String) lit.next(); //有需要的要强制转换成字符串格式
if ("b".equals(s)) {
	lit.add("b");
}
	System.out.println(s);  //输出  a,b,java,c
}
}
}

//8.创建了只能存储String类型数据的List集合，不可以进行数据类型转换，起到了数据保护的作用
//泛型一般只和集合结合使用
List<String> lit = new ArrayList<>();

//9.Collections工具类是专门用来对集合进行操作用的
//创建了只能存储String类型数据的List集合，不可以进行数据类型转换，起到了数据保护的作用
List<Integer> lit = new ArrayList<>();
lit.add(1);
lit.add(2);
lit.add(3);
lit.add(4);
lit.add(5);
lit.add(6);
lit.add(7);
System.out.println(lit);  //输出  [1, 2, 3, 4, 5, 6, 7]

Integer max = Collections.max(lit);
System.out.println(max);  //输出 7
Integer min = Collections.min(lit);
System.out.println(min);   //输出 1

//list集合进行升序排列
Collections.sort(lit);
System.out.println(lit);  //输出 [1, 2, 3, 4, 5, 6, 7]
//对集合进行逆序排列
Collections.reverse(lit);
System.out.println(lit);  //输出 [7, 6, 5, 4, 3, 2, 1]
//对集合进行随机排序
Collections.shuffle(lit);
System.out.println(lit);  //输出 [3, 7, 1, 5, 4, 6, 2]

//10.Set集合 无序，不能重复
//1.创建set集合对象，这里面的参数需要放入的是Student类里的对象
Set<Student> set = new HashSet<>();

//2.创建Student对象（这个对象里面有重复的乔峰），对于set集合不能有重复的对象
//所以在Student类中，需要重写equals()和hashcode()方法进行去重操作
Student stu1 = new Student("乔峰",41);
Student stu2 = new Student("乔峰",41);
Student stu3 = new Student("段誉",46);
Student stu4 = new Student("虚竹",35);

//3.set集合添加元素对象
set.add(stu1);
set.add(stu2);
set.add(stu3);
set.add(stu4);
System.out.println(set);
/**
* 输出：  在Student类中，没有重写的时候，重复的元素在里面
* [Student{name='虚竹', age=35}, Student{name='乔峰', age=41}, Student{name='乔峰', age=41},
* Student{name='段誉', age=46}]
* 输出：  在Student类中，重写equals()和hashcode()方法后：
* [Student{name='虚竹', age=35}, Student{name='段誉', age=46}, Student{name='乔峰', age=41}]
*/

//11.Map集合：有key和value，key不可以重复，value可以重复
//1.创建Map对象，对象是Student类，值是Integer类型
Map<Integer,Student> map = new HashMap<>();

//2.创建Student对象
Student stu1 = new Student("乔峰",41);
Student stu2 = new Student("杨过",41);
Student stu3 = new Student("段誉",46);
Student stu4 = new Student("虚竹",35);

//3.Map集合加入元素对象
map.put(1,stu1);
map.put(2,stu2);
map.put(3,stu3);
map.put(4, stu4);

//4.根据Key获取键值
Student ss = map.get(2);
System.out.println(ss);   //输出 Student{name='杨过', age=41}

/5.迭代器遍历Map集合
//1.获取所有键key的List集合
Set<Integer> keys = map.keySet();
//2.创建key的list集合迭代器对象
Iterator<Integer> it = keys.iterator();
while (it.hasNext()) { //如果迭代器中有元素，就一直迭代
	Integer key = it.next();  //获取元素，key的数据类型Integer要和Map的键数据类型一致
	//String key = (String)it.next(); 有需要的要强制转换成字符串格式，在这里不能转换，会报错
	Student values = map.get(key);
	System.out.println("Key" + key + "......vaules:" + values);
/**
* 输出：
* Key1......vaules:Student{name='乔峰', age=41}
* Key2......vaules:Student{name='杨过', age=41}
* Key3......vaules:Student{name='段誉', age=46}
* Key4......vaules:Student{name='虚竹', age=35}
*/
}

//通过增强for遍历Map集合
//1.获取所有键key的List集合
Set<Integer> keyss = map.keySet();
for (Object m1 : keyss) {
	Student values = map.get(m1);
	System.out.println(values);
}
/**
* 输出：
* Student{name='乔峰', age=41}
* Student{name='杨过', age=41}
* Student{name='段誉', age=46}
* Student{name='虚竹', age=35}
*/

//综合案例：模拟斗地主
int num = 0; //定义牌的编号
//1.定义一个双列集合 key：Integer 对应的值是牌
Map<Integer,String> pokers = new HashMap<>();
//2.定义一个List存放所有的牌的编号,牌编号是Integer类型
List<Integer> list =new ArrayList<>();
//3.用数组合成一副牌
String[] colours = {"红桃","黑桃","梅花","方片"};
String[] numbers = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
//将花色和牌数字一起组合形成牌
for (String colour : colours) { //获取所有的花色
	for (String number : numbers) {  //获取所有的点数
		String poker = colour + number;  //花色和点数组合成牌
		//将牌的编号和具体的牌放到双列集合Map集合中
		pokers.put(num,poker);
		//将牌的编号放到单列集合List集合中
		list.add(num);
		num++;
	}
}
	//Map集合中添加大王
	pokers.put(num, "大王");
	//List集合增加大王的序号
	list.add(num++);
	pokers.put(num, "小王");
	list.add(num++);

  //打印所有的牌
  System.out.println(pokers);
  /**
   * 输出：
   * {0=红桃2, 1=红桃3, 2=红桃4, 3=红桃5, 4=红桃6, 5=红桃7, 6=红桃8, 7=红桃9, 8=红桃10, 9=红桃J, 10=红桃Q,
   * 11=红桃K, 12=红桃A, 13=黑桃2, 14=黑桃3, 15=黑桃4, 16=黑桃5, 17=黑桃6, 18=黑桃7, 19=黑桃8, 20=黑桃9, 
   * 21=黑桃10, 22=黑桃J, 23=黑桃Q, 24=黑桃K, 25=黑桃A, 26=梅花2, 27=梅花3, 28=梅花4, 29=梅花5, 30=梅花6,
   * 31=梅花7, 32=梅花8, 33=梅花9, 34=梅花10, 35=梅花J, 36=梅花Q, 37=梅花K, 38=梅花A, 39=方片2, 40=方片3, 
   * 41=方片4, 42=方片5, 43=方片6, 44=方片7, 45=方片8, 46=方片9, 47=方片10, 48=方片J, 49=方片Q, 50=方片K, 
   * 51=方片A, 52=大王, 53=小王}
   */

//洗牌,把存放牌编号的list进行随机打乱
Collections.shuffle(list);

//发牌，三个人，定义4个集合，三个集合存放人获得牌，第四个集合存放底牌
List<Integer> liuyifei = new ArrayList<>();
List<Integer> zhaoliying = new ArrayList<>();
List<Integer> xiaohei = new ArrayList<>();
List<Integer> dipai = new ArrayList<>();
//将索引除3取模决定发牌给谁
for (int i = 0; i < list.size(); i++) {
	//获取牌的编号
	Integer pokerNum = list.get(i);
	if (i >= list.size() - 3) {
	//底牌
	dipai.add(pokerNum);
} else if (i % 3 == 0) {
	liuyifei.add(pokerNum);
} else if (i % 3 == 1) {
	zhaoliying.add(pokerNum);
} else if (i % 3 == 2) {
	xiaohei.add(pokerNum);
}
}
//查看玩家和底牌 这里获取的是每个人牌的编号
System.out.println("刘亦菲："+liuyifei);
System.out.println("赵丽引:"+zhaoliying);
System.out.println("小黑："+xiaohei);
System.out.println("底牌："+dipai);
/**
   * 输出： 
   * 刘亦菲：[51, 46, 6, 52, 28, 2, 53, 25, 23, 18, 49, 48, 43, 15, 21, 27, 20]
   * 赵丽引:[4, 26, 41, 11, 10, 45, 36, 30, 34, 40, 50, 42, 16, 47, 31, 33, 0]
   * 小黑：[1, 8, 17, 39, 12, 22, 5, 29, 35, 7, 37, 3, 14, 38, 44, 24, 19]
   * 底牌：[32, 9, 13]
   */
//获取每个人的具体的牌，另外创建了一个现实具体牌的类sendpoker类，里面有静态方法printpoker方法
//调用静态的方法可以是  sendpokerTest.printpoker() 也可以是下面的调用方法不用写类名，
//可以在这上面的函数继承sendpokerTest即可：extends sendPokerTest 
	String str1 = printPoker(liuyifei, pokers);
	System.out.println("刘亦菲："+str1);
	String str2 = printPoker(zhaoliying, pokers);
	System.out.println("赵丽引："+str2);
	String str3 = printPoker(xiaohei, pokers);
	System.out.println("小黑："+str3);
	String str4 = printPoker(dipai, pokers);
	System.out.println("底牌："+str4);

/**
* 输出：
* 刘亦菲：红桃2 红桃9 黑桃2 黑桃5 黑桃6 黑桃7 黑桃8 黑桃10 梅花4 梅花6 梅花A 方片2 方片3 方片6 方片7 方片9 方片10
* 赵丽引：红桃3 红桃5 红桃10 红桃J 红桃K 黑桃4 黑桃9 黑桃J 黑桃Q 梅花5 梅花9 梅花J 梅花K 方片5 方片Q 方片K 大王
* 小黑：红桃4 红桃6 红桃7 红桃8 红桃Q 红桃A 黑桃A 梅花2 梅花3 梅花8 梅花10 梅花Q 方片4 方片8 方片J 方片A 小王
* 底牌：黑桃3 黑桃K 梅花7
*/

//看牌，根据牌的编号获取牌，这个需要另外定义一个类来完成操作：
public class sendPokerTest {
	public static String printPoker(List<Integer> nums, Map<Integer,String> pokers){  //传入一个List放牌			的编号，一个Map放牌的集合
//1.对牌的编号就行升级排序
Collections.sort(nums);
//2.遍历牌的集合获取每一个牌的编号
//创建StringBuilder容器存放牌
StringBuilder sb = new StringBuilder();
for (Integer num : nums) {
	//根据编号去Map集合中去获取编号对应的具体的牌
	String poker = pokers.get(num);
	//将获取到的牌用空格进行拼接
	sb.append(poker+" ");
}
//3.将最后拼到的结果进行返回
String str = sb.toString();
//去除字符串两边的空格
return str.trim();
	}
}

/**1. Hashset底层数据结构是哈希表，存入的数据和取出的数据元素位置不一致
* 没有索引，不可以通过for遍历，不包含重复元素
*/
//创建集合对象
HashSet<String> hs = new HashSet<String>();
//添加元素
hs.add("hello");
hs.add("world");
hs.add("java");
//遍历
for (String h : hs) {
	System.out.println(h);  //输出：world java hello
}

//2.创建一个Student类，里面有private name和age属性，getter,setter方法，tostring()方法
//创建集合对象
HashSet<Student> hs = new HashSet<Student>();
Student stu= new Student("林青霞","30");
Student stu1 = new Student("张曼玉","26");
Student stu2 = new Student("王祖贤","63");
//添加元素
hs.add(stu);
hs.add(stu1);
hs.add(stu2);
//遍历
for (Student h : hs) {
    System.out.println(h.getName()+" "+h.getAge()); //输出：林青霞 30 张曼玉 26 王祖贤 63
}

/** linkedHashSet集合具有可预测的迭代次序
* 存储和取出顺序是一致的，由哈希表保证元素的唯一性，没有重复元素
*/
//创建集合对象
LinkedHashSet<String> hs = new LinkedHashSet<String>();
//添加元素
hs.add("java");
hs.add("world");
hs.add("hello");
//遍历
for (String h : hs) {
	System.out.println(h);  //输出：java world hello
}

/** 1.TreeSet():根据元素的自然排序进行排序
* TreeSet(Comparator comparator):根据指定的比较器进行排序
* 不能使用普通的for遍历，没有索引，不包含重复元素
*/
//创建集合对象
TreeSet<Integer> hs = new TreeSet<Integer>();
//添加元素
hs.add(10);
hs.add(40);
hs.add(30);
hs.add(90);
hs.add(70);
//遍历
for (Integer h : hs) {
	System.out.println(h);  //输出：10 30 40 70 90   按自然排序就是从小到大排序
}



/** 1.TreeSet():根据元素的自然排序进行排序
* TreeSet(Comparator comparator):根据指定的比较器进行排序
* 不能使用普通的for遍历，没有索引，不包含重复元素
*/
//创建集合对象
TreeSet<Student> hs = new TreeSet<Student>();
Student stu = new Student("西施","23");
Student stu1 = new Student("大桥","56");
Student stu2 = new Student("小乔","12");
Student stu3 = new Student("王昭君","78");
Student stu4 = new Student("貂蝉","26");
//添加元素
hs.add(stu);
hs.add(stu1);
hs.add(stu2);
hs.add(stu3);
hs.add(stu4);
//遍历
for (Student h : hs) {
	System.out.println(h.getName()+","+h.getAge());  
	//输出：当下面的Student类的return值设置为0的时候，输出结果：西施,23    （0输出第一个元素）
	/**输出：当下面的Student类的return值设置为1的时候，输出结果：         （1输出按顺序输出）          
						西施,23
						大桥,56
						小乔,12
						王昭君,78
						貂蝉,26
	*/
/**输出：当下面的Student类的return值设置为-1的时候，输出结果：			（-1输出按倒序输出）
						貂蝉,26
						王昭君,78
						小乔,12
						大桥,56
						西施,23
							*/
/**输出：当下面的Student类的return值设置为i的时候，
输出结果：return this.age-s.age 按年龄从小到大排列	，如果return s.age-this.age，那就是年龄从大到小排列了	
						小乔,12
						西施,23
						貂蝉,26
						大桥,56
						王昭君,78
							*/					
}

/**2.创建一个Student类，里面有private name和age属性，getter,setter方法，tostring()方法,
并且这个类 继承：
public class Student implements Comparable<Student>{
//2.1最后有一个重写方法：
 @Override
    public int compareTo(Student S) {
        return 0;  //这个return值可以设置为0或1或-1，对应的上面的输出结果不同
    }

//2.2重写方法还可以如下写：（因为的age是private String类型，所以要做一个转换）
@Override
public int compareTo(Student s) {
int i = Integer.parseInt(this.age)-Integer.parseInt(s.age);
return i;
} 
//2.2当age定义的是int类型的时候写法如下：
@Override
public int compareTo(Student s) {
int i = this.age - s.age;
return i;
} 
//年龄从小到大排列，年龄相同的时候，名字按拼音排列
public int compareTo(Student s) {
		//按照年龄的顺序排列从小到大
	int i = Integer.parseInt(this.age) - Integer.parseInt(s.age);
	//年龄相同的话，按照名字字母顺序排列
	int i1 = i == 0 ? this.name.compareTo(s.name) : i;
	return i1;
}

@Test
public void Test() {
//创建Collection集合
Collection col = new ArrayList();
//集合中添加元素
col.add("java");
col.add("hello");
col.add("world");
//迭代器遍历集合
Iterator it = col.iterator();
while (it.hasNext()) { //如果迭代器中有元素，就一直迭代
	String next = (String)it.next();
	System.out.println(next);    //输出：java hello world
}

//Properties集合
@Test
public void test2(){
//创建Properties集合对象（和map集合很类似）
Properties pro = new Properties();
//添加对象
pro.put("0001", "李刚");
pro.put("0002", "王五");
//遍历集合
Set<Object> keyss = pro.keySet();
for (Object key : keyss) {
	   Object values = pro.get(key);
	   System.out.println(key+","+values);
}
/**
* 输出结果：
* 0002,王五
* 0001,李刚
*/
}

@Test
public void test2() throws IOException {
//1.创建Properties集合对象（和map集合很类似）
Properties pro = new Properties();
//2.添加对象可以使用特有的方法setProperty
pro.setProperty("0001", "李刚");
pro.setProperty("0002", "王五");
//3.获取结果
System.out.println(pro.getProperty("0001"));  			//输出：李刚
System.out.println(pro.getProperty("00012")); 			 //对于不存在的key值：输出：null
System.out.println(pro); 						 				//输出：{0002=王五, 0001=李刚}
//4.只获取key值，返回一个不可修改的键集
Set<String> names = pro.stringPropertyNames();
for (String key : names) {
	System.out.println(key); 						//输出结果：0002   0001
	//获取所有键值
	String value = pro.getProperty(key);
	System.out.println(key+","+value);    //输出结果： 0002，王五    0001，李刚
	}
//5.把集合中的数据保存到文件1.txt，创建对象
FileWriter fw = new FileWriter("D:\\project\\src\\test\\java\\com\\qy\\spring5\\testdemo\\1.txt");
//写入保存文件
pro.store(fw, null);
//关闭资源
fw.close();
/**
* 1.txt里面的内容结果：
* #Sun Apr 11 20:35:53 CST 2021
* 0002=王五
* 0001=李刚
*
*/
}

//ArrayList集合
@Test
public void test8(){
/**
*ArrayList<E>:
* 是可调整大小的数组实现
* <E>:是一种特殊的数据类型，表示泛型
*/
//创建ArrayList对象
ArrayList<String> array = new ArrayList<>();
//添加元素
array.add("hello");
array.add("java");
System.out.println("array:"+array); //输出：array:[hello, java]
array.add(1,"胡启行");
System.out.println("array:"+array); //输出：array:[hello, 胡启行, java]
//删除hello元素
array.remove("hello");
System.out.println("array:"+array);   //输出：array:[胡启行, java]
//删除索引为1的元素
array.remove(1);
System.out.println("array:"+array);   //输出：array:[胡启行]
//更改元素
array.set(0, "胡启航");
System.out.println(array);   //输出：[胡启航]
//获取指定处索引元素值
System.out.println(array.get(0)); //输出：胡启航
//获取集合中元素个数
System.out.println(array.size()); //输出：1
//遍历集合
for (int i = 0; i < array.size(); i++) {
     System.out.println(array.get(i));  //输出：胡启航
 }
}

胡启行

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
16.list集合,增强for,迭代器,泛型，set集合，map集合,斗地主，HashSet集合，linkedHashSet集合，TreeSet集合,Collection集合,ArrayList集合

public class Student { public String name; public int age;public Student() {}public Student(String name, int age) { this.name = name; this.age = age;}@Overridepublic String toString() { return "Student{" + "name='" + name + '\''
复制链接

扫一扫