技术标签: 面试 算法 java 力扣算法题 JDK常用API 算法面试题 java常用API
算法第一步:先学API
实在是太多了,我刷了一百道左右,整理出来了里边用到的java中的API如下,有点乱,但是用的时候可以control+f进行搜索,当然这也是我的一个简化版本的API
char[] chars = str.toCharArray();
-转换为小写
String mm = "ASSXsdfsdfds";
String s = mm.toLowerCase(); // assxsdfsdfds
- 转换为大写
String s1 = mm.toUpperCase();// ASSXSDFSDFDS
用:==
char a = 'a';
char b = 'a';
if (a==b){
System.out.println("true");
}else {
System.out.println("false");
}
结果:true
// sort并不区分大小写,而是单单按照ABCD进行排序
// 存储所有英文字母
List<Character> letters = new ArrayList<>();
letters.add('A');
letters.add('a');
letters.add('f');
letters.add('F');
letters.add('B');
System.out.println(letters);
// 结果:[A, a, f, F, B]
// 不区分大小写排序
letters.sort(Comparator.comparingInt(a -> Character.toLowerCase(a)));
System.out.println(letters);
// 结果:[A, a, B, f, F]
// 区分大小写排序
letters.sort(Character::compare);
System.out.println(letters);
// 结果:[A, B, F, a, f]
java中关于ASCII码:
其实就是将
char aChar = chars[i];
int b = aChar;
因为char中仅仅存储一个字符,97或者两位数的数字他就会做一个特殊处理,会把数字映射成一个特殊的符号
同样也会把符号映射为一个数字。
char char4 =66;
输出char4为B
同样 int cha = char4
输出cha为66
int 和char是可以相互对等的,这里仅仅是涉及到一个符号转换
方式1:
String str = "one,two,three";
String[] parts = str.split(","); // 使用逗号作为分隔符
System.out.println(Arrays.toString(parts)); // 输出 [one, two, three]
方式2:
String str = "one two three";
String[] parts = str.split("\\s+"); // \s是正则表达式中表示空白字符的元字符,+表示一个或多个
System.out.println(Arrays.toString(parts)); // 输出 [one, two, three]
public static void main(String[] args) {
String input = "banana";
Set<Character> chars = new LinkedHashSet<>();
for (char c : input.toCharArray()) {
chars.add(c);
}
// 使用StringBuilder重新构建没有重复字符的字符串
StringBuilder sb = new StringBuilder(chars.size());
for (char c : chars) {
sb.append(c);
}
String result = sb.toString();;
// 打印去重后的结果 保留顺序 "ban"
System.out.println(result);
//----------------方式2-----------------------------
// 将字符串转换为字符数组
Character[] chars2 = input.chars().mapToObj(c -> (char) c).toArray(Character[]::new);
// 使用 TreeSet 去重并保持顺序
Set<Character> charSet = new TreeSet<>(Arrays.asList(chars2));
// 再次使用 StringBuilder 将字符集合构建回字符串
StringBuilder sb2 = new StringBuilder();
for (char ch : charSet) {
sb2.append(ch);
}
// 打印结果 // 结果将是不保留顺序 "abn"
System.out.println(sb2.toString());
}
String originalString = "banana";
char[] chars = originalString.toCharArray();
Arrays.sort(chars);
String sortedString = new String(chars);
System.out.println(sortedString); // 输出 "aaabnn"
对字符串数组进行排序,我们直接调用Arrays.sort()方法进行排序:
String[] strings = {
"Banana", "Apple", "Cherry", "Date"};
Arrays.sort(strings);
System.out.println(Arrays.toString(strings)); // 输出 [Apple, Banana, Cherry, Date]
字符串数组排序是区分大小写的。若想忽略大小写,可以提供一个自定义的Comparator:
Arrays.sort(strings, String.CASE_INSENSITIVE_ORDER);
System.out.println(Arrays.toString(strings)); // 输出 [Apple, Banana, Cherry, Date]
对于List,使用Collections.sort()方法:
List<String> listOfStrings = Arrays.asList("Banana", "Apple", "Cherry", "Date");
Collections.sort(listOfStrings);
System.out.println(listOfStrings); // 输出 [Apple, Banana, Cherry, Date]
忽略大小写进行字符串List排序:
Collections.sort(listOfStrings, String.CASE_INSENSITIVE_ORDER);
System.out.println(listOfStrings); // 输出 [Apple, Banana, Cherry, Date]
使用Java 8及以上版本时,可以使用Stream API来执行排序操作:
List<String> listOfStrings = Arrays.asList("Banana", "Apple", "Cherry", "Date");
listOfStrings.stream().sorted().forEach(System.out::println); // 输出排序后的字符串
忽略大小写的Stream排序:
listOfStrings.stream().sorted(String.CASE_INSENSITIVE_ORDER).forEach(System.out::println);
收集排序后的结果:
List<String> sortedList = listOfStrings.stream()
.sorted()
.collect(Collectors.toList());
以上是对字符串进行排序的常用方法。排序可以根据具体的业务规则和需求灵活选择大小写敏感或不敏感,自然排序或定制排序规则。
方式1:
String original = "hello";
String reversed = new StringBuilder(original).reverse().toString();
System.out.println(reversed);
// 结果:olleh
方式2:
List<Character> list = original.chars().mapToObj(c -> (char) c).collect(Collectors.toList());
Collections.reverse(list);
String reversed2 = list.stream().map(String::valueOf).collect(Collectors.joining());
System.out.println(reversed2);
当然还有很多种方式:但是
StringBuilder的reverse()方法效率是最高的
Scanner in = new Scanner(System.in);
String str = in.nextLine();
char c = in.nextLine().charAt(0);
// 获取下一个key 指定int类型忽略空格
final int key = in.nextInt();
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
float num = in.nextFloat();
确认步骤数:
int N = in.nextInt();
执行步骤数:
for (int i = 0; i < N; i++) {
int num = in.nextInt();
set.add(num);
}
1. 使用初始化器语法创建数组
int[] numbers = {
1, 2, 3, 4, 5}; // 初始化一个具有特定值的整型数组
2. 使用关键字new创建数组
int[] numbers = new int[5]; // 创建一个长度为5的整型数组,元素默认初始化为0
3. 使用关键字new和初始化器语法结合
int[] numbers = new int[]{
1, 2, 3, 4, 5}; // 使用new关键字,同时指定数组值
4. 使用Java 8的Arrays类填充默认值
String[] strings = new String[5];
Arrays.fill(strings, "Default"); // 创建一个字符串数组,然后用"Default"填充每个元素
5. 多维数组的创建
int[][] matrix = new int[3][3]; // 创建一个3x3的二维整型数组(矩阵),元素默认初始化为0
int[][] jaggedArray = new int[3][]; // 创建一个又叫"锯齿数组"的二维数组,其子数组长度可以不同
jaggedArray[0] = new int[2];
jaggedArray[1] = new int[3];
jaggedArray[2] = new int[1];
6. 使用java.util.ArrayList (或其他List)转换为数组
List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Integer[] numbers = list.toArray(new Integer[0]); // 从ArrayList创建一个Integer数组
7. 使用Stream API
int[] numbers = IntStream.range(0, 5).toArray(); // 创建一个元素从0到4的整型数组
String[] strings = Stream.of("apple", "banana", "cherry").toArray(String[]::new); // 创建一个包含特定值的字符串数组
int[] numbers = {
3, 5, 1, 4, 2};
Arrays.sort(numbers);
String[] names = {
"Bob", "Alice", "Charlie"};
Arrays.sort(names);
List<Integer> list = Arrays.asList(3, 5, 1, 4, 2);
Collections.sort(list);
List<String> namesList = Arrays.asList("Bob", "Alice", "Charlie");
Collections.sort(namesList);
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.add(3);
priorityQueue.add(5);
priorityQueue.add(1);
while (!priorityQueue.isEmpty()) {
System.out.print(priorityQueue.poll() + " "); // 输出为有序:1 3 5
}
SortedSet<String> sortedSet = new TreeSet<>();
sortedSet.add("Bob");
sortedSet.add("Alice");
sortedSet.add("Charlie");
for (String name : sortedSet) {
System.out.print(name + " "); // 输出为有序:Alice Bob Charlie
}
SortedMap<Integer, String> sortedMap = new TreeMap<>();
sortedMap.put(3, "Three");
sortedMap.put(1, "One");
sortedMap.put(2, "Two");
for (Map.Entry<Integer, String> entry : sortedMap.entrySet()) {
System.out.print(entry.getValue() + " "); // 输出为有序:One Two Three
}
实现方式: Java 8 引入了流(Stream) API,可以对集合、数组的流进行操作。流可以使用 sorted() 方法来排序,它能接受一个Comparator来自定义排序,如果没有指定Comparator,则会使用元素的自然排序。
代码示例:
List<Integer> numbersList = Arrays.asList(3, 5, 1, 4, 2);
numbersList.stream().sorted().forEach(System.out::print); // 输出为有序:12345
这些排序方法适用于不同的数据结构和场景。在实现自定义对象的排序时,通常需要对象实现Comparable接口或提供Comparator来定义对象间的排序规则。当需要为自定义对象排序时,你有两种主要的方式:
当你的类有一个自然的排序顺序时,可以实现 Comparable 接口并覆盖 compareTo 方法。例如,一个简单的 Person 类可能按姓名排序:
public class Person implements Comparable<Person> {
private String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
@Override
public int compareTo(Person other) {
return this.name.compareTo(other.name);
}
}
排序 Person 对象的列表:
List<Person> people = Arrays.asList(new Person("Bob"), new Person("Alice"), new Person("Charlie"));
Collections.sort(people);
for (Person person : people) {
System.out.println(person.getName());
}
// 输出将会是:
// Alice
// Bob
// Charlie
如果排序不是类的固有属性,或者你要对同一类的对象有不同的排序方式,那么可以提供 Comparator 接口的实现。以下是一个没有实现 Comparable 接口的 Person 类,但我们通过定义 Comparator 来排序:
public class Person {
private String name;
// 构造器、getter、setter省略
// 根据姓名排序的 Comparator
public static final Comparator<Person> BY_NAME = new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return p1.getName().compareTo(p2.getName());
}
};
// 根据姓名长度排序的 Comparator
public static final Comparator<Person> BY_NAME_LENGTH = new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return Integer.compare(p1.getName().length(), p2.getName().length());
}
};
}
如何使用:
List<Person> people = Arrays.asList(new Person("Bob"), new Person("Alice"), new Person("Charlie"));
Collections.sort(people, Person.BY_NAME);
for (Person person : people) {
System.out.println(person.getName()); // 输出按姓名排序的结果
}
Collections.sort(people, Person.BY_NAME_LENGTH);
for (Person person : people) {
System.out.println(person.getName()); // 输出按姓名长度排序的结果
}
List<Person> people = Arrays.asList(new Person("Bob"), new Person("Alice"), new Person("Charlie"));
// 使用Lambda表达式按姓名排序
people.sort((p1, p2) -> p1.getName().compareTo(p2.getName()));
// 使用Lambda和Comparator.comparing按姓名顺序排序
people.sort(Comparator.comparing(Person::getName));
// 使用Lambda和Comparator.comparing按姓名长度排序
people.sort(Comparator.comparingInt(p -> p.getName().length()));
使用流API:
people.stream()
.sorted(Comparator.comparing(Person::getName))
.forEach(p -> System.out.println(p.getName())); // 输出按姓名排序的结果
利用这些功能,你可以非常灵活地为Java中的数据结构实现排序逻辑,并根据具体应用场景选择最合适的方法。
List<String> names = Arrays.asList("Bob", "Alice", "Charlie");
names.stream()
.sorted()
.forEach(System.out::println);
// 自定义排序
names.stream()
.sorted((a, b) -> b.compareTo(a)) // 逆序
.forEach(System.out::println);
// 使用 Comparator.comparing 来指定排序规则
names.stream()
.sorted(Comparator.comparing(String::length).thenComparing(Comparator.naturalOrder()))
.forEach(System.out::println);
List<Person> people = Arrays.asList(new Person("Bob"), new Person("Alice"), new Person("Charlie"));
// 优先按姓名长度排序,然后按字母顺序排序
people.sort(Comparator.comparingInt((Person p) -> p.getName().length())
.thenComparing(Person::getName));
people.sort(Comparator.comparing(Person::getName)); // 使用方法引用按名字排序
List<String> names = Arrays.asList("Bob", "Alice", "Charlie");
names.parallelStream()
.sorted()
.collect(Collectors.toList()) // 收集排序后的结果到列表
.forEach(System.out::println);
结果:
Alice
Bob
Charlie
解释:
names.parallelStream()
parallelStream(): 这是Collection接口的一个方法,
用于创建一个可以并行处理元素的流(Stream)。
在并行流中,数据会被分割成多个段,每个段由不同的线程处理,
从而可以充分利用多核处理器的优势。
sorted(): 是Stream接口的一个方法,它会返回一个新的流,
其中包含按自然顺序排序的流中的所有元素。
collect: 是Stream接口的一个终结方法,它将流的内容转换成另一种形式,
这里用来将流转换为一个新的列表。
Collectors: 是一个工具类,里面提供了很多静态方法,用于生成常见的集合操作的收集器
toList(): 是Collectors类的一个静态方法,用于生成一个收集器,
将流中的元素累积到新的List中。
forEach: 又是Stream接口的一个终结方法,它接受一个Consumer接口的实现,
用来对流中的每个元素执行指定的操作。
System.out: 表示标准输出流(通常是控制台)。
println: 是PrintStream类的一个方法,用于输出信息到控制台。
System.out::println: 是一个方法引用,它是Consumer接口的实现,
表示对每个元素执行println方法。
总结:
这段代码展示的操作是将一个字符串列表并行地排序,并将排序后的结果收集到一个新的列表中
最后遍历这个列表,将每个字符串打印到控制台。由于采用了并行流,
各个元素的排序操作可以在不同的线程中同时进行,这可能在处理大数据集时提高性能。
不过,并行流并不总是提升性能,特别是在列表非常小或者操作本身非常快速时,
实际上可能会由于线程管理的开销而降低性能。
总的来说,Java拥有丰富的API和数据结构来支持排序操作。选择哪一个取决于具体的使用场景、性能要求和个人偏好。Java 8 引入的 Stream API 和 Lambda表达式进一步简化了排序操作,为开发者提供了更加优雅和现代的编码方式。
// 去重:set:
// 升序
TreeSet<Integer> set1 = new TreeSet<>();
// 降序
TreeSet<Integer> set2 = new TreeSet<>. (Comparator.reverseOrder());
//添加:
set1.add(2);
set1.add(1);
set1.add(6);
set1.add(4);
set1.add(4);
set1.add(4);
set2.add(2);
set2.add(1);
set2.add(6);
set2.add(6);
set2.add(6);
set2.add(4);
//遍历:
set1.stream().forEach(num -> {
System.out.println(num);});
set2.stream().forEach(num -> {
System.out.println(num);});
%表示取余数
\表示取整数
int padding = len % 8 == 0 ? 0 : 8 - len % 8;
len对8取余数,若是为0那么返回0,反之返回8-余数```
去重:set:
TreeSet<Integer> set = new TreeSet<>(); 升序
TreeSet<Integer> set = new TreeSet<>(Comparator.reverseOrder()); 降序
添加:
set.add(num);
遍历:
set.stream().forEach(num -> {
System.out.println(num);});
去重:
String[] strings = {
"1","2","6","5","4","2","5"};
// 使用ArrayList进行转换
List<String> list = new ArrayList<>(Arrays.asList(strings));
List<String> distinctList = list.stream().distinct().collect(Collectors.toList());
System.out.println(distinctList);
// 结果:[1, 2, 6, 5, 4]
String[] strings = {
"1","2","6","5","4","2","5"};
// 使用ArrayList进行转换 :将数组转换为集合
List<String> list = new ArrayList<>(Arrays.asList(strings));
System.out.println(list);
// 结果:[1, 2, 6, 5, 4, 2, 5]
String[] strings = {
"1","2","6","5","4","2","5"};
Set<String> set = new LinkedHashSet<>(Arrays.asList(strings));
System.out.println(set);
// 结果:[1, 2, 6, 5, 4]
String[] strings = {
"1","2","6","5","4","2","5"};
// 使用ArrayList进行转换
List<String> list = new ArrayList<>(Arrays.asList(strings));
// 排序
Collections.sort(list);
// 结果:[1, 2, 2, 4, 5, 5, 6]
String[] strings = {
"1","2","6","5","4","2","5"};
List<String> list = new ArrayList<>(Arrays.asList(strings)); // 使用ArrayList进行转换
Collections.reverse(list);
System.out.println(list);
// 结果:[5, 2, 4, 5, 6, 2, 1]
List<User> list = new ArrayList<>();
list.add(new User(1, "1"));
list.add(new User(5, "5"));
list.add(new User(2, "2"));
list.add(new User(6, "6"));
// 输出函数[User(age=1, name=1), User(age=5, name=5), User(age=2, name=2), User(age=6, name=6)]
System.out.println(list);
// 正序:[User(age=1, name=1), User(age=2, name=2), User(age=5, name=5), User(age=6, name=6)]
list.sort(Comparator.comparing(User::getAge));
System.out.println(list);
// 倒序:[User(age=6, name=6), User(age=5, name=5), User(age=2, name=2), User(age=1, name=1)]
list.sort(Comparator.comparing(User::getAge).reversed());
System.out.println(list);
List<User> users = Arrays.asList(
new User(25, "Alice"),
new User(30, "Bob"),
new User(25, "David"),
new User(25, "Charlie")
);
// 情况1: age相同按照名字正序排序
Comparator<User> ageThenNameAscending = Comparator
.comparing(User::getAge)
.thenComparing(User::getName);
users.sort(ageThenNameAscending);
System.out.println("Age then Name (Ascending):");
users.forEach(System.out::println);
// 结果:Age then Name (Ascending):
//User(age=25, name=Alice)
//User(age=25, name=Charlie)
//User(age=25, name=David)
//User(age=30, name=Bob)
// 情况2: age相同按照名字倒序排序
Comparator<User> ageThenNameDescending = Comparator
.comparing(User::getAge)
.thenComparing(User::getName, Comparator.reverseOrder());
users.sort(ageThenNameDescending);
System.out.println("\nAge then Name (Descending):");
users.forEach(System.out::println);
// 结果:Age then Name (Descending):
//User(age=25, name=David)
//User(age=25, name=Charlie)
//User(age=25, name=Alice)
List list = Arrays.asList("数值1", "数值2");
移除全部数据
alist.removeAll(list);
// 排序
Arrays.sort(a1);
// 创建数据
List<String[]> mergedArrays = new ArrayList<>();
// 创建一个Integer类型的ArrayList
List<Integer> list = new ArrayList<>();
// 向列表中添加整数元素
list.add(1);
list.add(3);
list.add(6);
list.add(12);
list.add(1);
// 使用Comparator对列表进行排序。由于这里排序的是Integer类型,因此可以简写为list.sort(null),因为Integer已经具有自然排序
list.sort(Comparator.comparing(Integer::valueOf));
// 遍历列表,使用方法引用打印出排序后的所有整数
list.forEach(System.out::println);
// 创建一个 User 类型的 ArrayList
List<User> list2 = new ArrayList<>();
// 创建User对象实例
User user = new User(1, "111");
User user2 = new User(2, "11111");
User user3 = new User(3, "1111111");
User user4 = new User(4, "111111111");
User user5 = new User(5, "11111111111");
User user6 = new User(6, "1111111111111");
// 向列表中添加User对象
list2.add(user);
list2.add(user4);
list2.add(user3);
list2.add(user2);
list2.add(user6);
list2.add(user5);
// 遍历列表,打印出添加顺序的User对象的字符串表示
list2.forEach(a -> System.out.println(a.toString()));
// 使用Comparator对User列表按年龄属性进行排序
list2.sort(Comparator.comparing(User::getAge));
// 再次遍历排序后的列表,打印出排序后的User对象的字符串表示
list2.forEach(a -> System.out.println(a.toString()));
// 例如,初始化 mergedArrays,这里只是一个例子
mergedArrays.add(new String[]{
"apple", "banana", "apple"});
mergedArrays.add(new String[]{
"pear", "banana", "pear", "kiwi"});
// 创建一个LinkedHashSet,保留元素顺序的同时去重
Set<String> distinctSet = new LinkedHashSet<>(Arrays.asList(strings));
// 使用TreeSet进行排序和去重
Set<String> sortedDistinctSet = new TreeSet<>(Arrays.asList(strings));
// 将去重后的结果转化回List,供进一步操作(比如排序)
List<String> distinctList = new ArrayList<>(distinctSet);
// 根据需要对去重后的列表排序
Collections.sort(distinctList);
// 更新mergedArrays中的数组
String[] distinctArray = distinctList.toArray(new String[0]);
同上:泛型为对象反转-按照某两个字段(及以上)排序
Map<String,String> map = new HashMap<>();
map.put("1","1");
map.put("5","5");
map.put("3","3");
map.put("4","4");
map.put("2","2");
// 使用TreeMap按键(key)排序
Map<String, String> sortedByKey = new TreeMap<>(map);
sortedByKey.forEach((k, v) -> System.out.println("Key: " + k + ", Value: " + v));
Map<String,String> map2 = new HashMap<>();
map2.put("1","11");
map2.put("5","53");
map2.put("3","13");
map2.put("4","12");
map2.put("2","12");
// 将Map的entrySet转换为List,并在List中使用自定义比较器按值(value)排序
List<Map.Entry<String, String>> entries = new ArrayList<>(map2.entrySet());
entries.sort(Map.Entry.comparingByValue());
entries.forEach(entiey->{
System.out.println("Key: " + entiey.getKey() + ", Value: " + entiey.getValue());
});
// 结果:
// Key: 1, Value: 1
//Key: 2, Value: 2
//Key: 3, Value: 3
//Key: 4, Value: 4
//Key: 5, Value: 5
Set<Map.Entry<String, String>> entries2 = map.entrySet();
List<Map.Entry<Character, Integer>> list222 = new ArrayList(entries2);
//按照value排序
list222.sort(Comparator.comparing(Map.Entry::getValue));
System.out.println(list222);
//按照key排序
list222.sort(Comparator.comparing(Map.Entry::getKey));
System.out.println(list222);
// 结果
//Key: 1, Value: 11
//Key: 2, Value: 12
//Key: 4, Value: 12
//Key: 3, Value: 13
//Key: 5, Value: 53
Map<String,String> map3 = new HashMap<>();
map3.put("1","1");
map3.put("5","5");
map3.put("3","3");
map3.put("4","4");
map3.put("2","2");
Set<Map.Entry<String, String>> entries2 = map3.entrySet();
List<Map.Entry<Character, Integer>> list111 = new ArrayList(entries2);
//按照value排序
list111.sort(Comparator.comparing(Map.Entry::getValue));
System.out.println(list111);
// 结果 [1=1, 2=2, 3=3, 4=4, 5=5]
Map<String,String> map4 = new HashMap<>();
map4.put("1","11");
map4.put("5","53");
map4.put("3","13");
map4.put("4","12");
map4.put("2","12");
//按照key排序
Set<Map.Entry<String, String>> entries22 = map4.entrySet();
List<Map.Entry<Character, Integer>> list222 = new ArrayList(entries22);
list222.sort(Comparator.comparing(Map.Entry::getKey));
System.out.println(list222);
//结果:[1=11, 2=12, 3=13, 4=12, 5=53]
关于哪种方法更好,这取决于具体需求:
从通用性和灵活性方面来看,将Map.Entry转换到List并排序通常是更好的选择,因为它允许你自定义排序逻辑,并且适用于按照value排序的场景。
然而,这种方法可能会略有性能损失,并且需要创建额外列表来保存排序结果。如果需要对Map进行大量排序操作,还要考虑性能和空间消耗因素。
Map<String, String> linkHashMap = new LinkedHashMap<>();
linkHashMap.put("1","1");
linkHashMap.put("5","5");
linkHashMap.put("3","3");
linkHashMap.put("4","4");
linkHashMap.put("2","2");
// 跳过前边几个元素
int skip = 3;
linkHashMap.entrySet().stream()
.skip(skip)
.forEach(entry -> {
// 在这里执行对键值对的操作
System.out.println(entry.getKey() + " " + entry.getValue());
});
// 结果:4 4
//2 2
for (Map.Entry<String, String> entry : linkHashMap.entrySet()) {
System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
for (String key : linkHashMap.keySet()) {
System.out.println("Key = " + key);
}
for (String value : linkHashMap.values()) {
System.out.println("Value = " + value);
}
Iterator<Map.Entry<String, String>> iterator = linkHashMap.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, String> entry = iterator.next();
System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
linkHashMap.forEach((key, value) -> System.out.println("Key = " + key + ", Value = " + value));
linkHashMap.entrySet().stream()
.forEach(entry -> System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()));
在选择遍历方式时,以下因素可能影响你的决定:
我推荐使用forEach或者传统的entrySet()迭代,原因如下:
对于大多数非并行处理的场景,forEach或者for循环均可满足要求,而且代码清晰直观。如果程序的性能是关键问题,并且确定传统的for循环有明显的性能优势,那么可能会选择
注意点:
1≤n≤2×10的9次方
java中表示10的8次方:int number = 1e8;
// 将十六进制字符串解析为十进制整数
String hex = "FF";
int decimal = Integer.parseInt(hex, 16);
System.out.println("Hex to Decimal: " + decimal);
// 将整数转换为二进制字符串
int number = 10;
String binary = Integer.toBinaryString(number);
System.out.println("Decimal to Binary: " + binary);
// 将整数转换为八进制字符串
int octalNumber = 15;
String octal = Integer.toOctalString(octalNumber);
System.out.println("Decimal to Octal: " + octal);
// 将整数转换为十六进制字符串
int hexNumber = 255;
String hexString = Integer.toHexString(hexNumber);
System.out.println("Decimal to Hex: " + hexString);
32位浮点数:范围
if (num < -3.4e38 || num > 3.4e38) {
System.out.println("输入的数字超出范围");
return;
}
关于代码中的:正则表达式相关的操作:
int count = 0;
String password = "123wefcsdvefr@#$dfvdfsgfgew123ADFCfwef";
if (password.matches(".*[a-z].*")) {
count++;
}
// 判断密码中是否包含至少一个大写字母
if (password.matches(".*[A-Z].*")) {
count++;
}
// 判断密码中是否包含至少一个数字
if (password.matches(".*\\d.*")) {
count++;
}
// 判断密码中是否包含至少一个非字母数字字符 这里使用了 ^ 表示取反,[^a-zA-Z0-9] 表示除了字母和数字之外的任意字符。如果密码中包含至少一个非字母数字字符,其实这个也能理解,若字符串中没有数字、字母那么必然是符号
if (password.matches(".*[^a-zA-Z0-9].*")) {
count++;
}
System.out.println("满足的数量:" + count);
建议自己也整理一份,因为千人千面,很难做到满足所有人,所以自己刷题,一定要整理
文章浏览阅读645次。这个肯定是末尾的IDAT了,因为IDAT必须要满了才会开始一下个IDAT,这个明显就是末尾的IDAT了。,对应下面的create_head()代码。,对应下面的create_tail()代码。不要考虑爆破,我已经试了一下,太多情况了。题目来源:UNCTF。_攻防世界困难模式攻略图文
文章浏览阅读2.9k次,点赞3次,收藏10次。偶尔会用到,记录、分享。1. 数据库导出1.1 切换到dmdba用户su - dmdba1.2 进入达梦数据库安装路径的bin目录,执行导库操作 导出语句:./dexp cwy_init/[email protected]:5236 file=cwy_init.dmp log=cwy_init_exp.log 注释: cwy_init/init_123..._达梦数据库导入导出
文章浏览阅读1.9k次。1. 在官网上下载KindEditor文件,可以删掉不需要要到的jsp,asp,asp.net和php文件夹。接着把文件夹放到项目文件目录下。2. 修改html文件,在页面引入js文件:<script type="text/javascript" src="./kindeditor/kindeditor-all.js"></script><script type="text/javascript" src="./kindeditor/lang/zh-CN.js"_kindeditor.js
文章浏览阅读2.3k次,点赞6次,收藏14次。SPI的详情简介不必赘述。假设我们通过SPI发送0xAA,我们的数据线就会变为10101010,通过修改不同的内容,即可修改SPI中0和1的持续时间。比如0xF0即为前半周期为高电平,后半周期为低电平的状态。在SPI的通信模式中,CPHA配置会影响该实验,下图展示了不同采样位置的SPI时序图[1]。CPOL = 0,CPHA = 1:CLK空闲状态 = 低电平,数据在下降沿采样,并在上升沿移出CPOL = 0,CPHA = 0:CLK空闲状态 = 低电平,数据在上升沿采样,并在下降沿移出。_stm32g431cbu6
文章浏览阅读1.2k次,点赞2次,收藏8次。数据链路层习题自测问题1.数据链路(即逻辑链路)与链路(即物理链路)有何区别?“电路接通了”与”数据链路接通了”的区别何在?2.数据链路层中的链路控制包括哪些功能?试讨论数据链路层做成可靠的链路层有哪些优点和缺点。3.网络适配器的作用是什么?网络适配器工作在哪一层?4.数据链路层的三个基本问题(帧定界、透明传输和差错检测)为什么都必须加以解决?5.如果在数据链路层不进行帧定界,会发生什么问题?6.PPP协议的主要特点是什么?为什么PPP不使用帧的编号?PPP适用于什么情况?为什么PPP协议不_接收方收到链路层数据后,使用crc检验后,余数为0,说明链路层的传输时可靠传输
文章浏览阅读587次。软件测试工程师移民加拿大 无证移民,未受过软件工程师的教育(第1部分) (Undocumented Immigrant With No Education to Software Engineer(Part 1))Before I start, I want you to please bear with me on the way I write, I have very little gen...
文章浏览阅读304次。Thinkpad X250笔记本电脑,装的是FreeBSD,进入BIOS修改虚拟化配置(其后可能是误设置了安全开机),保存退出后系统无法启动,显示:secure boot failed ,把自己惊出一身冷汗,因为这台笔记本刚好还没开始做备份.....根据错误提示,到bios里面去找相关配置,在Security里面找到了Secure Boot选项,发现果然被设置为Enabled,将其修改为Disabled ,再开机,终于正常启动了。_安装完系统提示secureboot failure
文章浏览阅读10w+次,点赞93次,收藏352次。1、用strtok函数进行字符串分割原型: char *strtok(char *str, const char *delim);功能:分解字符串为一组字符串。参数说明:str为要分解的字符串,delim为分隔符字符串。返回值:从str开头开始的一个个被分割的串。当没有被分割的串时则返回NULL。其它:strtok函数线程不安全,可以使用strtok_r替代。示例://借助strtok实现split#include <string.h>#include <stdio.h&_c++ 字符串分割
文章浏览阅读2.3k次。1 .高斯日记 大数学家高斯有个好习惯:无论如何都要记日记。他的日记有个与众不同的地方,他从不注明年月日,而是用一个整数代替,比如:4210后来人们知道,那个整数就是日期,它表示那一天是高斯出生后的第几天。这或许也是个好习惯,它时时刻刻提醒着主人:日子又过去一天,还有多少时光可以用于浪费呢?高斯出生于:1777年4月30日。在高斯发现的一个重要定理的日记_2013年第四届c a组蓝桥杯省赛真题解答
文章浏览阅读851次,点赞17次,收藏22次。摘要:本文利用供需算法对核极限学习机(KELM)进行优化,并用于分类。
文章浏览阅读1.1k次。一、系统弱密码登录1、在kali上执行命令行telnet 192.168.26.1292、Login和password都输入msfadmin3、登录成功,进入系统4、测试如下:二、MySQL弱密码登录:1、在kali上执行mysql –h 192.168.26.129 –u root2、登录成功,进入MySQL系统3、测试效果:三、PostgreSQL弱密码登录1、在Kali上执行psql -h 192.168.26.129 –U post..._metasploitable2怎么进入
文章浏览阅读257次。本文将为初学者提供Python学习的详细指南,从Python的历史、基础语法和数据类型到面向对象编程、模块和库的使用。通过本文,您将能够掌握Python编程的核心概念,为今后的编程学习和实践打下坚实基础。_python人工智能开发从入门到精通pdf