[蓝桥杯] Java相关知识
|
Java,算法
|
49

317 字
|
32 分钟 
// 数组定义
// 1. 不赋值
int[] arr = new int[5];

// 2. 赋值
int[] arr = {1, 2, 3, 4, 5};
int[] arr = new int[]{1, 2, 3, 4, 5};

// 多维数组
// 1. 不赋值
int[][] arr = new int[3][4]; // 3行4列

// 2. 赋值
int[][] arr = {{1, 2}, {3, 4}}; // 2行2列
int[][] arr = new int[][]{{1, 2}, {3, 4}}; // 2行2列

// 3. 不规则数组
int[][] arr = new int[3][]; // 3行不规则数组
arr[0] = new int[2]; // 第一行2列
arr[1] = new int[3]; // 第二行3列

// 数组的一些常用方法
// 1. 数组长度
int length = arr.length; // 数组长度

// 2. 数组排序 可以排数字或字母，字母按ASCII码排序
Arrays.sort(arr); // 数组排序（升序）
Arrays.sort(arr, Collections.reverseOrder()); // 数组排序（降序）
Arrays.sort(arr, 0, 3); // 数组排序（升序）从第0个到第3个（不包括第3个）
Arrays.sort(arr, 0, 3, Collections.reverseOrder()); // 数组排序（降序）从第0个到第3个（不包括第3个）

// 3. 数组复制
// 3.1 System.arraycopy() 速度最快
System.arraycopy(arr, 0, arr2, 0, arr.length); // （源数组, 源数组起始位置, 目标数组, 目标数组起始位置, 复制长度）
// （复制长度小于目标数组长度时，剩余部分会用0填充）

// 3.2 Arrays.copyOf()
int[] arr2 = Arrays.copyOf(arr, arr.length); // （源数组, 复制长度）（如果复制长度大于源数组长度，则会用0填充）（不包括结束位置）
// 3.3 Arrays.copyOfRange()
int[] arr2 = Arrays.copyOfRange(arr, 0, 3); // （源数组, 起始位置, 结束位置）（不包括结束位置）

// 3.4 Arr.clone() 慢
int[] arr2 = arr.clone();

// 4. Java中Arrays类的常用方法
Arrays.toString(arr); // 数组转字符串

Arrays.fill(arr, 0); // 用0填充数组

Arrays.equals(arr1, arr2); // 数组比较

int[] arr = {1, 2, 3, 4, 5};
Arrays.binarySearch(arr, 3); // 二分查找（前提是数组必须是有序的） 返回下标 2
Arrays.binarySearch(arr, 0, 3, 3); // （从0到3位（不包括3）查找3） 返回下标 2


// ArrayList
// 1. 创建
ArrayList<Integer> al = new ArrayList<>(); // <>中是引用数据类型

// 2. 长度
int length = al.size();

// 3. 遍历
for(int i = 0; i < al.size(); i++) {
    System.out.println(al.get(i));
}

// 4. 增删改查
// 4.1 增
al.add(100);

// 4.2 删
al.remove(0); // 索引

// 4.3 改
al.set(0, 200); // 索引, 值

// 4.4 查
int nums = al.get(0); // 索引

// 5. 排序
Collections.sort(al); // 可排数字或字符列表

/* ************************************************************************************** */

// LinkedList
// 1. 创建
LinkedList<Integer> ll = new LinkedList<>();

// 2. 长度
int length = ll.size();

// 3. 遍历
for(int i = 0; i < ll.size(); i++) {
    System.out.println(ll.get(i));
}

// 4. 增删改查
// 4.1 增
ll.add(1);
// 头部添加元素
ll.addFirst(2);
// 尾部添加元素
ll.addLast(3);

// 4.2 删
// 头部删除元素
ll.removeFirst();
// 尾部添加元素
ll.removeLast();

// 4.3 改
ll.set(0, 100); // 索引, 值

// 4.4 查
int nums = al.get(0); // 索引
// 获取头部元素
int nums = ll.getFirst();
// 获取尾部元素
int nums = ll.getLast();

// 5. 排序
Collections.sort(al); // 可排数字或字符列表

/* ************************************************************************************** */

// LinkedList（使用Queue接口）
// 1. 创建
Queue<Integer> queue = new LinkedList<>();

// 2. 长度
int length = queue.size();

// 3. 遍历
// 方法1：增强for循环（不破坏队列）
for (int num : queue) {
    System.out.println(str);
}

// 方法2：依次取出元素（会清空队列）
while (!queue.isEmpty()) {
    System.out.println(queue.poll());
}

// 4. 增删改查
// 4.1 增
// 添加元素到队尾
queue.offer(1);   // 成功返回true
queue.add(2);    // 成功返回true，失败抛异常

// 4.2 删
// 移除并返回队头元素
String head1 = queue.poll();  // 队列空时返回null
String head2 = queue.remove(); // 队列空时抛异常

// 4.3 改，标准队列无法直接修改元素

// 4.4 查
// 查看但不移除队头元素
String peek1 = queue.peek();    // 返回"A"，队列不变（队列空时返回null）
String peek2 = queue.element(); // 返回"A"，队列不变（队列空时抛异常）
// 检查元素是否存在
boolean contains = queue.contains(1);  // 返回true
// 转换为数组查看
Object[] array = queue.toArray();

/* ************************************************************************************** */

// Vector
// 1. 创建
Vector<Integer> vec = new Vector<>(); // 默认初始容量10，支持泛型
Vector<Integer> vec2 = new Vector<>(20); // 指定初始容量

// 2. 长度
int length = vec.size(); // 实际元素数量

// 3. 遍历
for (int i = 0; i < vec.size(); i++) {
    System.out.println(vec.get(i));
}

// 4. 增删改查
// 4.1 增
vec.add(100); // 尾部追加（自动扩容）
vec.add(1, 200); // 指定索引插入（需移动元素）
vec.addElement(300); // 等价于add()（历史遗留方法）

// 4.2 删
vec.remove(0); // 按索引删除（返回被删元素）
vec.remove(Integer.valueOf(100)); // 按值删除（需遍历）
vec.removeElementAt(1); // 历史遗留方法
vec.clear(); // 清空所有元素

// 4.3 改
vec.set(0, 50); // 按索引修改（返回旧值）
vec.setElementAt(50, 0); // 历史遗留方法

// 4.4 查
int num = vec.get(0); // 按索引查询
int first = vec.firstElement(); // 获取首元素（历史方法）
int last = vec.lastElement(); // 获取尾元素（历史方法）
boolean exists = vec.contains(100); // 检查元素是否存在

// 5. 排序
Collections.sort(vec); // 升序排序（同ArrayList）

/* ************************************************************************************** */

// HashSet
// 1. 创建
Hash<Integer> hs = new HashSet<>();

// 2. 长度
int length = hs.size();

// 3. 遍历（增强for）
for (int num : hs) {
    System.out.println(num);
}

// 4. 增删改查
// 4.1 增
hs.add(100); // 添加元素（返回true/false）（若元素已存在，则返回false）

// 4.2 删
hs.remove(100); // 删除元素（返回true/false）
hs.clear(); // 清空所有元素

// 4.3 改，HashSet不支持修改元素

// 4.4 查
boolean exists = hs.contains(100); // 检查元素是否存在

// 十进制转其他进制
// Integer.toString(k,r) ，将十进制的数k转换为r进制的数。返回一个String。
int r =2;
System.out.println(Integer.toString(k,r)); //转r进制
r=8;
System.out.println(Integer.toString(k,r)); //转r进制
r=16;
System.out.println(Integer.toString(k,r)); //转r进制

// 其他进制转十进制
// Integer.parseInt(s,r) ，将r进制的数s转换为十进制的数。返回一个int。
System.out.println(Integer.parseInt("10001",2));
System.out.println(Integer.parseInt("21",8));
System.out.println(Integer.parseInt("11",16));

// 保留小数位数
// String.format()
double a = 123.456789;
double b = 123.444444;
String sa = String.format("%.2f",a);
System.out.println(sa);
String sb = String.format("%.2f",b);
System.out.println(sb);

//输出
123.46
123.44

//简写
System.out.println(String.format("%.2f",a));
// StringBuilder
public class StringBuilderDemo {
    public static void main(String[] args) {
        // 创建一个StringBuilder对象
        StringBuilder sb = new StringBuilder("Hello");

        // 1. 追加字符串
        sb.append("World");
        System.out.println("After append: " + sb);

        // 2. 插入字符串（6表示插入位置的索引）
        sb.insert(6, "Java ");
        System.out.println("After insert: " + sb);

        // 3. 替换字符串（6到10的字符串被替换为"C++"）
        // 注意：replace方法的参数是起始索引和结束索引（不包括结束索引）
        sb.replace(6, 10, "C++");
        System.out.println("After replace: " + sb);

        // 4. 删除字符串
        // 注意：delete方法的参数是起始索引和结束索引（不包括结束索引）
        sb.delete(6, 10);
        System.out.println("After delete: " + sb);

        // 5. 反转字符串
        sb.reverse();
        System.out.println("After reverse: " + sb);

        // 6. 获取长度和容量
        System.out.println("Length: " + sb.length());
        System.out.println("Capacity: " + sb.capacity());

        // 7. 设置长度
        sb.setLength(5);
        System.out.println("After setLength: " + sb);

        // 8. 转换为String
        String result = sb.toString();
        System.out.println("Converted to String: " + result);

        // 9. 获取字符
        char ch = sb.charAt(0);
        System.out.println("Character at index 0: " + ch);

        // 10. 获取子字符串
        String subStr = sb.substring(1, 4); // 注意：substring方法的参数是起始索引和结束索引（不包括结束索引）
        System.out.println("Substring from index 1 to 4: " + subStr);

        // 11. 查找字符或字符串
        int index = sb.indexOf("o"); // 查找字符'o'的索引
        System.out.println("Index of 'o': " + index);
    }
}
本人邮箱：yhyshiroha123@outlook.jp
Java保留小数位数字符串数组进制转换集合
暂无评论

发送评论 编辑评论 


				

			

						

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
							
													

					

				

			

			
			

				

					
				

			

				

											

							
							
						

																

							
							
						

																

							
							
						

										
					
											
						

	

		
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
（╯‵□′）╯︵┴─┴
￣﹃￣
(/ω＼)
∠( ᐛ 」∠)＿
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ｀)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ(￣∇￣o)
ヾ(´･ ･｀｡)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò｡)
Σ(っ °Д °;)っ
( ,,´･ω･)ﾉ"(´っω･｀｡)
╮(╯▽╰)╭
o(*////▽////*)q
＞﹏＜
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
	

	

		
颜文字
Emoji
小恐龙
花!
	


									

			

			
			
		

	






上一篇

                    

                    
			        推荐文章
		            

		            

							
仿射密码

							
							

							
[基础算法]排序

							
							

							
[Java EE] Java + MySQL

							
							

							
[Java EE] Vue

							
							

							
[Java EE] Spring Boot项目基础

							
							

							
[基础算法]二分

							
							

							
八数码难题

							
							

							
[基础算法]递推与递归