2.8及其之前整理

最新推荐文章于 2024-10-01 18:51:18 发布

hyftgx

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量35

点赞数

文章标签： java

本文链接：https://blog.csdn.net/hyftgx/article/details/122822756

版权

增强for循环：
格式：for（集合/数组的数据类型变量名：集合名/数组名）
sout（变量名）
package Learn;

public class forxunhuan {
public static void main(String[] args) {
int[] arr= {1,2,3,4,5};
for(int i:arr){
System.out.println(i);
}

}
}
Itertator接口也是有泛型的，集合是什么泛型，集合就是什么泛型
Collection<String> coll = new ArrayList<>();
coll.add("aaa");
coll.add("bbb");
coll.add("ccc");
Iterator<String> abc = coll.iterator();
while (abc.hasNext()) {
String e = abc.next();
System.out.println(e);
斗地主案例的实现：
package Learn;

import java.security.Key;
import java.util.*;

public class learn117 {
public static void main(String[] args) {
/*
准备牌，创建一个map集合，存储索引和牌张
然后创建一个list集合，创建牌的索引
定义两个集合存储花色和牌张
*/
HashMap<Integer, String> poker = new HashMap<>();
ArrayList<Integer> pokerindex = new ArrayList<>();
List<String> color = List.of("♠", "♥", "♣", "♦");
List<String> number = List.of("2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
int index = 0;
poker.put(index, "大王");
pokerindex.add(index);
index++;
poker.put(index, "小王");
pokerindex.add(index);
index++;
for (String numbers : number) {
for (String colors : color) {
poker.put(index, colors + numbers);
pokerindex.add(index);
index++;
}

}
// System.out.println(poker);
/*
洗牌使用collection中的shuffle（list）

*/
Collections.shuffle(pokerindex);
ArrayList<Integer> person1 = new ArrayList<>();
ArrayList<Integer> person2 = new ArrayList<>();
ArrayList<Integer> person3 = new ArrayList<>();
ArrayList<Integer> dipai = new ArrayList<>();
for (int i = 0; i < pokerindex.size(); i++) {
Integer in = pokerindex.get(i);
if (i >= 51) {
dipai.add(in);

} else if (i%3==0) {
person1.add(in);
} else if (i%3==2) {
person2.add(in);

} else if (i%3==1) {
person3.add(in);

}

}
Collections.sort(person1);
Collections.sort(person2);
Collections.sort(person3);
Collections.sort(dipai);
/*
查表发：
便利万家或者鸡排集合，获取牌的索引
使用牌的索引，去mao集合中，找到对应的牌

*/
lookpaper("张三",poker,person1);
lookpaper("李四",poker,person2);
lookpaper("王五",poker,person3);
lookpaper("底牌",poker,dipai);
}

public static void lookpaper(String name,HashMap<Integer,String> poker,ArrayList<Integer> list){
//输出玩家名称，不换行
System.out.print(name+":");
//遍历玩家和底牌集合，获取牌的索引
for (Integer key : list) {
String value = poker.get(key);
System.out.print(value);
}
System.out.println();
}
}

List方法：
java接口的特点：
该接口extends Collection接口
1有序的集合
2.有索引，包含了一些带索引的方法
3.允许存储重复的元素
List接口带索引的方法
add.添加元素
add（从第几个添加，添加什么）
get 返回集合中指定位置的元素就是获取某个元素
remove 溢出指定的元素返回被移除的元素
set（第几个元素替换的第几个元素）用指定元素替换集合中指定位置的元素，返回值的更新前的元素
arraylist不是同步的是多线程的。
LinkedList集合：
List接口的链接列表实现。（查询慢增删快）
特点：1.底层是一个链表结构的：查询慢增删快
2.里面包含了大量操作首位元素的方法
注意：使用LinkedList集合特有的方法，不能使用多态。
list.addFirst=list.addpush 获取第一个元素
list.addLast获取最后一个元素
List.getFirst List.getLast
isEmpt 如果元素不包括某个元素则返回ture 可以！一起用

list.removeFirst=list.pop 移除第一个

vector：可以实现可增长的对象数组。
Set接口：一个不包含重复元素的collection
这个集合中没有索引，所以跟collection集合一样
没有索引不能使用普通的for循环遍历
HashSet

不保证迭代的顺序，特别是他不保证顺序的永恒性不同步的
没有索引，也不能使用普遍的for循环遍历
4.底层是一个哈希表结构，查询的非常的块

哈希值：是一个十进制的证书，游戏用随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来得到地址，不是数据实际存在的）
hashCode 返回该对象的哈希值。
pubilc native int hashCode（）;
native代表该方法调用的是本地操作系统的方法
HashSet集合存储的结构：
JDK1.8版本之前哈希表=数组+链表
JDK1.8版本之后哈希值=数组+链表/数组+红黑树（提高查询的速度）
哈希表特点：速度快。
数组结构：吧元素进行了分组，相同哈希值的元素十一组
链表/红黑树结构：吧相同哈希值连接到一起
两个元素不同但是哈希值相同哈希冲突查询时先插叙单个哈希值，然后相同哈希值寻找想要的数据
当含有8个以上的相同哈希值数据时，则采用红黑树查询以便于更快查询

set集合不允许存储重复集合的原理
set集合在调用add方法时，add方法会调用元素的hashCode方法和equals方法，判断元素是否重复
add方法会调用s1的hashCode方法计算字符串abc的哈希值，哈希值是96354，在集合中有没有96354这个哈希值，发现没有
就会把s1存储到集合中
add会调用s2的hashcode方法，在集合中发现有，s2会调用equals方法和哈希值相同的元素比较s2.equals（s1），返回true
两个元素的哈希值相同，equals返回ture，认定元素相同，就不会吧s2存储到集合中。
所以综上是先判定哈希值是否相同然后在判定元素是否相同，判定是否存储。
HashSet存储自定义类型元素
set集合报错元素唯一：
存储的元素（Steing Integer...）必须重写hashCode方法和equals方法
要求：同名同年龄的人，十位同一个人，只能存储一次。

LinkedHashset
具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。注意，插入顺序不受在 set 中重新插入的元素的影响。
LinkedHashSet集合的特点
底层是一个哈希表+链表，多了一条链表（记录元素的顺序），保证元素有序，也不允许重复。
可变参数：
使用前提：当方法的参数列表数据类型已经确定，但是参数个数不确定，就可以是用可变参数。
使用格式：定义方法是使用
修饰符返回值类型方法命（数据类型..变量名）{}
可变参数的原理：可变参数底层就是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储这些参数
传递的参数格式，可以是0个（不传递），可以是多个

package Learn;

import java.util.LinkedList;

public class learn117 {
public static void main(String[] args) {
int i = add(5);//里面有几个数组的元素就是几个

}
public static int add (int a,int b,int c ){
return a+b+c;
}
public static int add(int...arr){
int sum = 0;
for (int i : arr) {
sum+=i;
return sum;
}
System.out.println(arr);//底层是一个数组
System.out.println(arr.length);//数组的长度
return 0;
}
可变参数的注意事项：
1.一个方法的参数列表，只能有一个可变参数
如果方法的参数有多可，那么可变参数必须卸载参数列表的末尾
可变参数的特殊写法：
public static void method（Object...obj）{
}

Collections常用功能、
忘记和中添加多个元素：
Collections.addAll(list,""""")
打乱集合
Collections.shuffle（list）；
sout（list）
让集合中的元素按照相应的顺序排序：
Collections.sort（list）；默认是升序
注意事项
需要重写排序的规则
public int compareTo（person o）{
//return0；//认为元素都是相同的
//自动以比较的排序，比较两个人的年龄（this 参数person）
return this.getAge() - o.getAge();

}
Coparable(this.getAge-o.getAge)升序否则降序。

任务65：(N)2.8.3Collections集合工具类的方法_sort(List,Comparator)
Comparator和Coparable的区别：
Coparable：自己（this）和别人（参数）比较自己需要实现Coparable接口，重写比较的规则ComoareTo方法
Comparator：相当于找一个第三方的裁判，比较两个
package Learn;

import java.util.*;

public class learn117 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(3);
list.add(2);
Collections.sort(list, new Comparator<Integer>() {
@Override//重写比较的规则
public int compare(Integer o1, Integer o2) {
return o1-o2;//升序
//return o2-o1 降序
}
});
System.out.println(list);
}

}
一次写多个规则
fori（result == 0）{
result = o1.gerName（）.charAt（0）-o2.gerName（）.charAt（0）}
return result