Java基础知识总结（持续更新中）

Java基础知识（持续更新）

类型转化：数字、字符串、字符之间相互转化

  1. 数字 <-> 字符串
// 数字转字符串
//  method1int number = 5;String str = String.valueOf(number);//  method2int number = 5;Integer itr = number;  //int装箱为对象，再调用对象的toString方法String str = itr.toString(); //或者直接 String str = Integer.toString(number);// method3int number = 5;String str = number + "";// 字符串转数字String str = "123";int number = Integer.parseInt(str);
  1. 字符串 <-> 字符
// 字符串转字符
// method 1  单个字符String str = "123";char ch = str.charAt(0); //charAt(index)方法，这里获取到的字符为1// method 2 for (int i = 0; i < str.length(); i++) {System.out.println(str.substring(i, i + 1));}// method 3  字符串转成字符数组String str = "123";char [] charArray = str.toCharArray();// 单字符转字符串
// method 1char ch = '5';String str = String.valueOf(ch);// method 2char ch = '5';String str = ch + "";// method 3 字符数组转化成字符串 String newStr = new String(charArray, 0, charArray.length);
  1. 字符 <-> 数字
// 字符转数字
// method 1char ch = '5';int a = ch - '0';// method 2 （ 字符 -> 字符串 -> 数字 ）// 先把字符转为字符串，再转换为数字char ch = '5';String temp = String.valueOf(ch);int a = Integer.parseInt(temp);// 数字转字符 （ 数字 -> 字符串 -> 字符 ）// 不能直接转换，因此需借助数字转字符串。// 首先将数字转为字符串，再获取字符int number = 5; //注意这里数字只能是个位数并且不能为负String s = Integer.toString(number);char ch = s.charAt(0);
  1. 与数组之间的转化
// String -> char[]
String s = "3456789XJQKA2MF";
char [] charArray = s.toCharArray();// char[] -> String
String s = new String(charArray, 0, charArray.length);// 将 ch[i] 设为空 ch[i] = '\0'// List -> Integer
List<Integer> nums
Integer[] arr = nums.toArray(new Integer[0]);

String类

  1. 字符串相减/替换

使用 String 类的 replace() 方法来实现这个功能: replace(“target”,“replacement”)

如果你想将引号添加到字符串中，你可以使用转义字符 \" 来表示双引号。

String str1 = "abcdefg";
String str2 = "bcd";
String result = str1.replace(str2, "");
System.out.println(result);  // 输出: aefg
  1. 字符串连接

使用 String 类的 concat() 方法来实现这个功能: contact(String s)

也可以用StringBuilder类来添加，空间效率更快

 String s = "菜鸟教程";s = s.concat("网址:").concat("www.runoob.com");System.out.println(s);    //输出 菜鸟教程网址:www.runoob.com
  1. 比较子/字符串是否相同
  • equals() 方法
String str1 = "abc";
String str2 = "123a";
str1.equals(str2);    //输出 false
"abc".equals(str2);    //输出 true
  • equalsIgnoreCase() 方法 --不区分大小写
String str1 = "abc";
String str2 = "ABC";
System.out.println(str1.equalsIgnoreCase(str2));    // 输出 true
  • compareTo() 方法

compareTo() 方法用于按字典顺序比较两个字符串的大小，该比较是基于字符串各个字符的 Unicode 值。

String str1 = "A";
String str2 = "a";
System.out.println(str1.compareTo(str2));    // a - A 输出 32
System.out.println(str2.compareTo(str1));    // A - a 输出 -32
System.out.println(str2.compareTo("a"));    // 相同输出 0
  1. 字符串是否包含

contains() 方法

String str = "abcdef";
boolean statue = srt.contains("bc");    // statue = true;
  1. 获取子字符串

  • substring(int beginIndex)

    1. 这个版本的substring方法从指定的索引位置开始，提取字符串的一部分，一直到字符串的末尾。

  • substring(int beginIndex, int endIndex)

    • 这个版本的substring方法从指定的起始索引位置开始，提取字符串的一部分，直到结束索引之前的位置。

    • public class SubstringExample {public static void main(String[] args) {String s = "Hello, world!";// 第1个substring方法// 使用单个索引，提取从索引2开始到末尾的子字符串String substring1 = s.substring(2);System.out.println("Substring 1: " + substring1); // 输出：llo, world!// 第2个substring方法// 使用两个索引，提取从索引7到索引12之前的子字符串，即 7 - 11 String substring2 = s.substring(7, 12);System.out.println("Substring 2: " + substring2); // 输出：world// 提取索引4之前的子字符串（索引4不包括在内）String substring3 = s.substring(0, 4);System.out.println("Substring 3: " + substring3); // 输出：Hell}
}
  1. 查找 字符/串 位置

  • int indexOf(String str)：

    1. 这个版本的 indexOf 方法用于查找指定子字符串在字符串中第一次出现的索引位置。

  • int indexOf(String str,int fromIndex):

    • 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

    • public class IndexOfExample {public static void main(String[] args) {String text = "Hello, world! This is a sample text.";// 第1个indexOf方法// 查找字符 ',' 第一次出现的索引int commaIndex = text.indexOf(',');System.out.println( commaIndex); // 输出： 5// 查找子字符串 "world" 第一次出现的索引int worldIndex = text.indexOf("world");System.out.println( worldIndex); // 输出： 7// 查找不存在的字符或子字符串int notFoundIndex = text.indexOf("123");System.out.println( notFoundIndex); // 输出：-1// 第二个indexOf方法String t = text.indexOf("o",6);System.out.println( t); // 输出： 8}
}
  1. 进制转化

十进制转化为其他进制

public static boolean check(int base, int num){ // 进制位， 转换数int t = num;int sum = 0;while (t != 0){sum += t % base;t /= base;}return num % sum == 0;}System.out.println(n + "的三进制是:" + Integer.toString(n, 3));
System.out.println(n + "的二进制是:" + Integer.toBinaryString(n));
System.out.println(n + "的八进制是:" + Integer.toOctalString(n));
System.out.println(n + "的十六进制是:" + Integer.toHexString(n));

其他进制转为十进制

r进制转10进制方法
radix进制的字符串s转10进制Integer.parseInt((String) s,(int) radix);
    public static void main(String[] args) {String a = "1001";int s = Integer.parseInt(a, 2);// 二进制转十进制System.out.println(s);}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  1. 大小写变换
s = s.toLowerCase(); //转换成小写
s = s.toUpperCase(); //转换成大写
String 方法

下面是 String 类支持的方法，更多详细，参看 Java String API 文档:

序号方法描述
1char charAt(int index) 返回指定索引处的 char 值。
2int compareTo(Object o) 把这个字符串和另一个对象比较。
3int compareTo(String anotherString) 按字典顺序比较两个字符串。
4int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。
5String concat(String str) 将指定字符串连接到此字符串的结尾。
6boolean contentEquals(StringBuffer sb) 当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。
7[static String copyValueOf(char] data) 返回指定数组中表示该字符序列的 String。
8[static String copyValueOf(char] data, int offset, int count) 返回指定数组中表示该字符序列的 String。
9boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
10boolean equals(Object anObject) 将此字符串与指定的对象比较。
11boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。
12[byte] getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
13[byte] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
14[void getChars(int srcBegin, int srcEnd, char] dst, int dstBegin) 将字符从此字符串复制到目标字符数组。
15int hashCode() 返回此字符串的哈希码。
16int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
17int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
18int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。
19int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
20String intern() 返回字符串对象的规范化表示形式。
21int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
22int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
23int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。
24int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
25int length() 返回此字符串的长度。
26boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。
27boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
28boolean regionMatches(int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
29String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
30String replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
31String replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
32[String] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
33[String] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串。
34boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。
35boolean startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
36CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列，它是此序列的一个子序列。
37String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。
38String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。
39[char] toCharArray() 将此字符串转换为一个新的字符数组。
40String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
41String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
42String toString() 返回此对象本身（它已经是一个字符串！）。
43String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
44String toUpperCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
45String trim() 返回字符串的副本，忽略前导空白和尾部空白。
46static String valueOf(primitive data type x) 返回给定data type类型x参数的字符串表示形式。
47contains(CharSequence chars) 判断是否包含指定的字符系列。
48isEmpty() 判断字符串是否为空。

StringBuilder/StringBuffer类

当对字符串进行修改的时候，使用 StringBuffer / StringBuilder 类更方便。和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。方法类似

public class RunoobTest{public static void main(String args[]){StringBuilder sb = new StringBuilder(10);// 创建对象并设置字符序列长度为 10，也可不设置// StringBuilder/StringBuff 常用方法// 追加字符 append(String s/ char c)sb.append("Runoob..");// 插入字符 insert(int offset, String s)sb.insert(7, "Java");// 删除字符 delete(int start, int end)sb.delete(4,7);// 替换字符 replace(int start, int end, String str)// 反转字符 reverse()sb.reverse();// 字符串形式表示 toString()sb.toString()}
}
StringBuffer 方法

以下是 StringBuffer 类支持的主要方法：

序号方法描述
1public StringBuffer append(String s) 将指定的字符串追加到此字符序列。
2public StringBuffer reverse() 将此字符序列用其反转形式取代。
3public delete(int start, int end) 移除此序列的子字符串中的字符。
4public insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。
5insert(int offset, String str) 将 str 参数的字符串插入此序列中。
6replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。

以下列表列出了 StringBuffer 类的其他常用方法：

序号方法描述
1int capacity() 返回当前容量。
2char charAt(int index) 返回此序列中指定索引处的 char 值。
3void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。
4void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst。
5int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。
6int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
7int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。
8int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。
9int length() 返回长度（字符数）。
10void setCharAt(int index, char ch) 将给定索引处的字符设置为 ch。
11void setLength(int newLength) 设置字符序列的长度。
12CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。
13String substring(int start) 返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
14String substring(int start, int end) 返回一个新的 String，它包含此序列当前所包含的字符子序列。
15String toString() 返回此序列中数据的字符串表示形式。

Math类

  1. 对数字开方

Math.sqrt(16) -> 4

  1. 对数字取整数

向上取整：Math.ceil(double a) [n/x] = [(n+x-1)/x] 向下取整：Math.floor(double a) 四舍五入取整：Math.round(double a)

例：

Math.ceil（24.1）–> 25

Math.floor（24.8）–> 24

Math.round（24.1）–> 24

Math.round（24.8）–> 25

import java.text.DecimalFormat;
public class Main {public static void main(String[] args) {double number1 = 25.00000;double number2 = 5432.10;//"#.######"指定了保留六位有效数字,小数点后不足6位不补0DecimalFormat decimalFormat = new DecimalFormat("#.######");// 设置最小小数位数为0，不写也可以decimalFormat.setMinimumFractionDigits(0); String formattedNumber1 = decimalFormat.format(number1);String formattedNumber2 = decimalFormat.format(number2);System.out.println(formattedNumber1); // 输出：25System.out.println(formattedNumber2); // 输出：5432.1}
}
  1. 高精度计算(数大于long)
import java.math.BigDecimal;
public class HighPrecisionExample {public static void main(String[] args) {// 使用字符串构造BigDecimal以确保精度准确BigDecimal num1 = new BigDecimal("123.456");BigDecimal num2 = new BigDecimal("789.012");// 加法BigDecimal sum = num1.add(num2);// 减法BigDecimal difference = num1.subtract(num2);// 乘法BigDecimal product = num1.multiply(num2);// 除法，指定精度和舍入模式BigDecimal quotient = num1.divide(num2, 10, BigDecimal.ROUND_HALF_UP);// ROUND_HALF_UP 四舍五入 ROUND_UP（向上取 ROUND_DOWN 向下取}
}
Number & Math 类方法

下面的表中列出的是 Number & Math 类常用的一些方法：

序号方法与描述
1xxxValue() 将 Number 对象转换为xxx数据类型的值并返回。
2compareTo() 将number对象与参数比较。
3equals() 判断number对象是否与参数相等。
4valueOf() 返回一个 Number 对象指定的内置数据类型
5toString() 以字符串形式返回值。
6parseInt() 将字符串解析为int类型。
7abs() 返回参数的绝对值。
8ceil() 返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。
9floor() 返回小于等于（<=）给定参数的最大整数 。
10rint() 返回与参数最接近的整数。返回类型为double。
11round() 它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
12min() 返回两个参数中的最小值。
13max() 返回两个参数中的最大值。
14exp() 返回自然数底数e的参数次方。
15log() 返回参数的自然数底数的对数值。
16pow() 返回第一个参数的第二个参数次方。
17sqrt() 求参数的算术平方根。
18sin() 求指定double类型参数的正弦值。
19cos() 求指定double类型参数的余弦值。
20tan() 求指定double类型参数的正切值。
21asin() 求指定double类型参数的反正弦值。
22acos() 求指定double类型参数的反余弦值。
23atan() 求指定double类型参数的反正切值。
24atan2() 将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
25toDegrees() 将参数转化为角度。
26toRadians() 将角度转换为弧度。
27random() 返回一个随机数。

Arrays类

  1. 数组创建
//一维数组int [] a = new int [10];
// 二维数组String[][] s = new String[3][4];//或   列可以先不写，后面要创建String[][] s = new String[2][];s[0] = new String[2];s[1] = new String[3];
//定义包含 first 属性的类
class MyObject {int first;// 构造函数public MyObject(int first) {this.first = first;}
}public class Main {public static void main(String[] args) {// 创建一个包含三个 MyObject 对象的数组MyObject[] myArray = new MyObject[2];// 初始化数组中的每个元素myArray[0] = new MyObject(10);myArray[1] = new MyObject(20);myArray[0].first = 12;// 访问数组中的第一个元素的 first 属性int value = myArray[0].first;System.out.println("Value of first in the first element: " + value);// Value of first in the first element: 12}
}
  1. For-Each循环

JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

for(type element: array)
{System.out.println(element);
}double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (double element: myList) {System.out.println(element);
}
  1. 数组赋值

一维数组填充

int [] map = new int [5];
Arrays.fill(map,1); // 将 map数组 填充为 1

二维数组填充

int[][] map=new int[4][5];
Arrays.fill(map,-1); // 失败int[][] map=new int[4][5];
int[] ten=new int[10];
Arrays.fill(ten, -1);
Arrays.fill(map,ten); // 成功
//特别注意：map 的每一项指向的都是同一个一维数组 ten。修改一个会影响其他地址的值 ，
//如：修改 map[0][1] = 100 ,则 map[1][1] ，map[2][1]等都是100.
  1. 数组排序
// 升序
Arrays.sort(int[] a); // 从小到大,升序
Arrays.sort(int[] a, int fromIndex, int toIndex);//对数组部分排序，区间左闭右开//多维数组
// 先f[0]升序，若f[0]相同，按f[1]降序
Arrays.sort(f, (o1, o2) -> o1[0] == o2[0] ? o2[1] - o1[1] : o1[0] - o2[0]);//排序

建议使用Collections.sort()方法，比Arrays.sort()效率高

public static void sort(int[] arr) {List<Integer> list = new ArrayList<>();for (int i : arr) {list.add(i);}Collections.sort(list);for (int i = 0; i < arr.length; i++) {arr[i] = list.get(i);}}
// 降序
//首先要注意的是不能用int这个类型了，要用Integer，不能使用基本类型（int,double, char）
//如果是int型需要改成Integer，float要改成Float
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;public class Main {public static void main(String[] args) {Integer[] arr2={1,4,3,6,7,9,11};Arrays.sort(arr2, Collections.reverseOrder());System.out.println(Arrays.toString(arr2));}
}// 冒泡排序：降序
public static void sort(int[] arr) {int n = arr.length;for (int i = 0; i < n - 1; i++) {for (int j = 0; j < n - 1 - i; j++) {// 如果相邻元素逆序，则交换它们if (arr[j] < arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}
}
  1. 数组比较
Arrays.equals() 适用于一维数组的比较。
Arrays.deepEquals() 更适合用于多维数组，特别是当数组中包含其他数组时。例子：
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean judge = Arrays.equals(arr1, arr2)); // trueint[][] matrix1 = {{1, 2}, {3, 4}};
int[][] matrix2 = {{1, 2}, {3, 4}};
boolean judge =Arrays.deepEquals(matrix1, matrix2); // true
// 方法源代码
public static boolean equals(long[] a, long[] a2) {if (a.length != a2.length) return false;for (int i = 0; i < a.length; i++) {if (a[i] != a2[i])  return false;}return true;
}
  1. 指定值第一次出现下标

public static int binarySearch(Object[] a, Object key)

用二分查找算法在数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好。如果查找值包含在数组中，则返回索引；否则返回 -1

Arrays.binarySearch(数组, 开始, 结束, 值)；

Arrays.binarySearch( arr , 0 , 10 , 5 );在下表为 0 - 9 中搜索

public static void main(String[] args) {int[] array = {5, 2, 9, 1, 5, 6};// 对数组进行排序Arrays.sort(array);// 要查找的值int targetValue = -9;// 使用binarySearch查找值的下标int index = Arrays.binarySearch(array, targetValue);System.out.println(index);
}
  1. 数组转化为List

Arrays.asList()方法

String[] a = {"apple", "banana", "orange", "grape"};
List<String> list = new ArrayList<>(Arrays.asList(a));// 不支持结构修改（add、remove 操作）
List<String> list = Arrays.asList(a);

Integer类

  1. 校验数据是否为int、double、string类型的方法 instanceof
String sContentValue = "1234567";
boolean bCheckResult = true;
try
{Integer iCheckValue = Integer.parseInt(sContentValue);if (iCheckValue instanceof Integer == false){bCheckResult = false;}
}
catch(NumberFormatException e)
{  bCheckResult = false;
}

Collection类

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  1. List 集合排序

只有List集合可以使用Collections.sort(List list)进行排序，若为其他类型集合转化为List集合

Collections.sort(List list)方法（升序排序）

Collections.sort(List list, Collections.reverseOrder());对有序集合降序排序（降序排序）

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;public class Main {public static void main(String[] args) {List<Integer> numbers = new ArrayList<>();numbers.add(5);numbers.add(2);numbers.add(8);numbers.add(1);// 使用Collections.sort()方法升序排序Collections.sort(numbers);// 降序排序// 法1：推荐Collections.sort(numbers, Collections.reverseOrder());// 法2：Lambda 表达式的排序降序排序Collections.sort(b, (x,y)->y-x);//或list.sort((o1, o2) -> o2 - o1);}
}
  1. 遍历集合

遍历ArrayList

import java.util.*;public class Test{public static void main(String[] args) {List<String> list=new ArrayList<String>();list.add("Hello");list.add("World");list.add("HAHAHAHA");//第一种遍历方法使用 For-Each 遍历 Listfor (String str : list) {            //也可以改写 for(int i=0;i<list.size();i++) 这种形式System.out.println(str);}//第二种遍历，把链表变为数组相关的内容进行遍历String[] strArray=new String[list.size()];list.toArray(strArray);for(int i=0;i<strArray.length;i++) //这里也可以改写为  for(String str:strArray) 这种形式{System.out.println(strArray[i]);}//第三种遍历 使用迭代器进行相关遍历Iterator<String> ite=list.iterator();while(ite.hasNext())//判断下一个元素之后有值{System.out.println(ite.next());}}
}

遍历Map

import java.util.*;public class Test{public static void main(String[] args) {Map<String, String> map = new HashMap<String, String>();map.put("1", "value1");map.put("2", "value2");map.put("3", "value3");//第一种：普遍使用，二次取值System.out.println("通过Map.keySet遍历key和value：");for (String key : map.keySet()) {System.out.println("key= "+ key + " and value= " + map.get(key));}//第二种System.out.println("通过Map.entrySet使用iterator遍历key和value：");Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();while (it.hasNext()) {Map.Entry<String, String> entry = it.next();System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());}//第三种：推荐，尤其是容量大时System.out.println("通过Map.entrySet遍历key和value");for (Map.Entry<String, String> entry : map.entrySet()) {System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());}//第四种System.out.println("通过Map.values()遍历所有的value，但不能遍历key");for (String v : map.values()) {System.out.println("value= " + v);}}
}

ArrayList集合–元素可重复有序

import java.util.ArrayList; // 引入 ArrayList 类
ArrayList<E> objectName =new ArrayList<>();　 // 初始化
//例如
ArrayList<String> sites = new ArrayList<String>();
  • E: 泛型数据类型，泛型String Integer Character Boolean等引用数据类型
  • objectName: 对象名。
  1. 排序
List<Integer> numbers = new ArrayList<>();
numbers.add(5);numbers.add(2);
numbers.add(8);numbers.add(1);// 使用Collections.sort()方法升序排序
Collections.sort(numbers);// 降序排序// 法1：推荐Collections.sort(numbers, Collections.reverseOrder());// 法2：Lambda 表达式的排序降序排序list.sort((o1, o2) -> o2 - o1);
  1. 删除元素
  • remove(int index)：删除指定索引处的元素。
List<Integer> numbers = new ArrayList<>();
numbers.remove(3); // 删除下标为3的元素
  • remove(Object o)：删除第一次出现的指定元素。
List<Integer> numbers = new ArrayList<>();
Integer a = 3；
numbers.remove(a);// 删除第一次出现的3List<String> list = new ArrayList<>();
list.remove("abc");// 删除字符串abc
  • boolean removeAll(Collection<?> c)：是否删除另一个集合所有元素
public class RemoveAllExample {public static void main(String[] args) {// 创建一个ArrayListArrayList<String> list1 = new ArrayList<>(Arrays.asList("apple", "banana", "orange", "grape"));// 创建另一个ArrayList，包含要移除的元素List<String> elementsToRemove = Arrays.asList("banana", "grape");// 使用removeAll移除包含在elementsToRemove中的元素boolean result = list1.removeAll(elementsToRemove);if (result) {System.out.println("移除成功，剩余的元素：" + list1);} else {System.out.println("列表未发生改变，没有移除任何元素。");}}
}
常用方法
ArrayList集合常用方法
方法描述
add()将元素插入到指定位置的 arraylist 中
addAll(Collection c)将一个集合所有元素添加到另一个集合
clear()删除 arraylist 中的所有元素
clone()复制一份 arraylist
contains(Object obj)判断元素是否在 arraylist
get(int index)通过索引值获取 arraylist 中的元素
indexOf()返回 arraylist 中元素的第一次出现的索引值
removeAll()删除存在于指定集合中的 arraylist 里的所有元素
remove()删除 arraylist 里的单个元素
size()返回 arraylist 里元素数量
isEmpty()判断 arraylist 是否为空
subList()截取部分 arraylist 的元素
set()替换 arraylist 中指定索引的元素
sort()对 arraylist 元素进行排序
toArray()将 arraylist 转换为数组
toString()将 arraylist 转换为字符串
ArrayList 常用方法
添加元素：
add(E element): 在列表末尾添加一个元素。
add(int index, E element): 在指定索引位置插入一个元素。获取元素：
get(int index): 获取指定索引位置的元素。修改元素：
set(int index, E element): 修改指定索引位置的元素。删除元素：
remove(int index): 删除指定索引位置的元素。
remove(Object obj): 删除第一个出现的指定元素。
// 如 remove(Integer.valueOf(30);// 
clear(): 清空列表中的所有元素。查找元素：
indexOf(Object obj): 返回指定元素第一次出现的索引，如果不存在则返回 -1。
lastIndexOf(Object obj): 返回指定元素最后一次出现的索引，如果不存在则返回 -1。
contains(Object obj): 判断列表是否包含指定元素。获得集合大小：
size(): 返回列表中元素的数量。获得子列表：
subList(int fromIndex, int toIndex): 返回从 fromIndex 到 toIndex 之间的子列表。isEmpty(): 判断列表是否为空。数组转换：
toArray(): 将列表转换为数组。
//例如
String[] arr = new String[sites.size()];
sites.toArray(arr);toString()：将Arraylist对象转换为字符串。

HashSet集合–元素不可重复乱序

import java.util.HashSet; // 引入 HashSet 类
//下面两种形式都可以
HashSet<E> sites = new HashSet<E>();
Set<E> set = new HashSet<>();
// 例如：
HashSet<String> sites = new HashSet<String>();
Set<Character> set = new HashSet<>();
获取HashSet元素
// 通过迭代器获取元素Iterator<String> iterator = linkedHashSet.iterator();while (iterator.hasNext()) {String element = iterator.next();System.out.println(element);}// 或者将 LinkedHashSet 转换为数组String[] array = linkedHashSet.toArray(new String[0]);for (String element : array) {System.out.println(element);}

HashSet 常用方法同 ArrayList 一样，无get()方法

详细参考–菜鸟教程Java HashSet，如下

https://www.runoob.com/java/java-hashset.html

HashSet 按插入顺序排列

用HashSet存储元素，HashSet不保证元素的顺序，它是基于哈希表实现的，元素的存储顺序与它们的哈希码有关，而哈希码与元素的插入顺序无关。

如果你希望输出的元素按照插入的顺序进行排列，你可以考虑使用LinkedHashSet。LinkedHashSet是HashSet的一个子类，它保留了元素的插入顺序。只需稍微修改你的代码，将HashSet替换为LinkedHashSet

如： Set set = new LinkedHashSet<>();

Map类

// 引入 HashMap 类      
import java.util.HashMap;
public class RunoobTest {public static void main(String[] args) {// 创建 HashMap 对象 SitesHashMap<Integer, String> Sites = new HashMap<Integer, String>();// 添加键值对Sites.put(1, "Google");Sites.put(2, "Runoob");Sites.put(3, "Taobao");Sites.put(4, "Zhihu");System.out.println(Sites);}
}

HashMap 常用方法：

方法描述
clear()删除 hashMap 中的所有键/值对
clone()复制一份 hashMap
isEmpty()判断 hashMap 是否为空
size()计算 hashMap 中键/值对的数量
put()将键/值对添加到 hashMap 中
putAll()将所有键/值对添加到 hashMap 中
putIfAbsent()如果 hashMap 中不存在指定的键，则将指定的键/值对插入到 hashMap 中。
remove()删除 hashMap 中指定键 key 的映射关系
containsKey()检查 hashMap 中是否存在指定的 key 对应的映射关系。
containsValue()检查 hashMap 中是否存在指定的 value 对应的映射关系。
replace()替换 hashMap 中是指定的 key 对应的 value。
replaceAll()将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。
get()获取指定 key 对应对 value
getOrDefault()获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
forEach()对 hashMap 中的每个映射执行指定的操作。
entrySet()返回 hashMap 中所有映射项的集合集合视图。
keySet()返回 hashMap 中所有 key 组成的集合视图。
values()返回 hashMap 中存在的所有 value 值。
merge()添加键值对到 hashMap 中
compute()对 hashMap 中指定 key 的值进行重新计算
computeIfAbsent()对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中
computeIfPresent()对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。

队列

PriorityQueue 是 Java 中的一个优先队列实现，通过默认情况下是一个小顶堆（元素按升序排列）来实现。如果你希望使用大顶堆（元素按降序排列），你可以通过提供一个 Collections.reverseOrder() 的比较器来实现。以下是用中文描述的代码：

import java.util.Collections;
import java.util.PriorityQueue;public class Main {public static void main(String[] args) {// 创建一个大顶堆优先队列PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());// 添加元素到优先队列pq.add(3);pq.add(1);pq.add(4);pq.add(1);pq.add(5);// 弹出并打印堆顶元素while (!pq.isEmpty()) {System.out.println(pq.poll());}}
}

IO流

BufferedReader的使用方法
import java.io.*;
public class Main {public static void main(String[] args) throws IOException {//创建BufferedReader对象，从键盘读入BufferedReader br=new BufferedReader(new InputStreamReader(System.in));       String str = br.readLine();  //读取一行字符串，br.readLine()读取的为字符串类型int n = br.read(); // 读取一个字符，返回对应 ASCII 的值int a = Integer.parseInt(str);  //将字符转化为整型br.ready();// 判断是否还有下一个，返回类型 booleanString[] temp=br.readLine().split(" ");//读取一行数据并用空格分隔，存入字符串数组}
}// 或String str1 = null ;        // 接收输入内容try{str1 = br.readLine() ;        // 只能读取一行数据}catch(IOException e){e.printStackTrace() ;        // 输出信息}
import java.io.*;
import java.util.StringTokenizer;public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String s = br.readLine();// 使用空格作为分隔符创建StringTokenizer对象StringTokenizer st = new StringTokenizer(s);// 获得字符串数量int n = st.countTokens();System.out.println(n);// 遍历并打印每个标记while (st.hasMoreTokens()) {String token = st.nextToken();System.out.println(token);}}
}
Scanner的使用方法
import java.util.Scanner;
public class Main {public static void main(String[] args){Scanner sc = new Scanner(System.in);//创建Scanner类对象，从键盘读入数据int temp3 = sc.nextInt();double temp4 = sc.nextDouble();boolean temp5 = sc.nextBoolean();// true / falseString temp2 = sc.next();//读取字符直到判断输入结束String temp1 = sc.nextLine();//读取下一行数据long temp = sc.hasNextLong();boolean temp = sc.hasNext(String str);//输入的字符与str比较，返回true/falsesc.hasNext();// 判断是否还有下一个，返回类型 booleansc.hasNextLine();// 判断是否还有下一行是，返回类型 booleanString [] s = sc.nextLine().split(" ");sc.useDelimiter(" ");//若以空格分隔字符串，需要读取空格才能继续读取//或者使用一个空的sc.nextLine()跳过空格 PS：此方法可以设置其他分隔符}
}

基础知识

  1. ASCII码

在这里插入图片描述

在这里插入图片描述

  1. 位运算符
  • 按位与（&）：对应位上的两个二进制数都为1时，结果为1，否则为0。
result = a & b;
  • 按位或（|）：对应位上的两个二进制数只要有一个为1时，结果为1，否则为0。
result = a | b;
  • 按位异或（^）：对应位上的两个二进制数不相同时，结果为1，相同时结果为0。
result = a ^ b;
  • 按位取反（~）：对二进制数的每一位取反，0变为1，1变为0。
result = ~a;
  • 左移（<<）：将二进制数向左移动指定的位数，右侧用0填充。
result = a << n;
  • 右移（>>）：将二进制数向右移动指定的位数，左侧用符号位填充（对于有符号整数）。
result = a >> n;
  1. 数据类型及范围

获取某类型最大值 MAX_VALUE，例如：int a = Integer.MAX_VALUE

  • 整数类型：

    • byte: 8位，1字节，范围为 -128 到 127 = 2^7-1

    • short: 16位，2字节，范围为 -32768 到 32767 = 2^15-1

    • int: 32位，4字节，范围为 -2147483648 到 2147483647 = 2^31-1 = 2*10^10

    • long: 64位，16字节，范围为 -9223372036854775808

      到9223372036854775807 = 2^63-1 = 9 *10^19

      超过int范围，后面＋L 如：long b = 10000000000L

  • 浮点数类型：

    • float: 32位，4字节，范围为约 ±3.4E38
    • double: 64位，64字节，范围为约 ±1.7E308

  • 字符类型：

    • char: 16位，2字节范围为 0 到 65535。表示Unicode字符。

  • 布尔类型：

    • boolean:一般认为1字节 只有两个可能值，true 或 false。
  1. 单位换算

  • bit(比特) < byte(字节) < kb < mb < gb < tb < pb

    1 byte = 8 bit 1 kb = 1024 byte 1mb =1024 kb

    1 gb = 1024 mb 1 tb = 1024 gb 1 pb = 1024 tb

  • 1s = 1000 ms

  1. 输出格式：对齐方式和宽度控制
// 每个数字占5个位置，右对齐（从最右边输出，在前面补空格）
System.out.printf("%5d",i);   // 每个数字占5个位置，左对齐（从最左边输出，后面补齐空格）
System.out.printf("%-5d",i);// 输出小数控制
// 说明：%f默认保留6位，.后面的表示的是小数四舍五入保留的位数
System.out.printf("%.2f",3.1415926);   //小数点后保留2位，即 3.14// 输出类型 printf short -- %hdlong  -- %ldlong long -- %lldboolean -- %b// 输出 %
System.out.printf("%.2f%%",81.82);   //将%输在小数后面，即 81.82% // 例子
//六位整数+一位小数点+三位小数=_314315.142（右对齐，左边补一个空格）
System.out.printf("%11.3f\n",314315.1415926);  
System.out.printf("%10.3f\n",314315.1415926);  //6+1+3=10 正好=314315.142
System.out.printf("%11.4f\n",314315.1415926);  //6+1+4=11 正好=314315.1426
System.out.printf("%8.3f\n",314315.1415926);   //6+1+3>8 正常输出=314315.142
System.out.printf("%14.3f\n",314315.1415926);  //6+1+3=14-4 补四个空格=_ _ _ _314315.142

在这里插入图片描述

double p = 0.235987565146
// 四舍五入保留4位小数，后面又0省略 如 p = 230.1 -> 230.1
DecimalFormat form=new DecimalFormat("0.####");
System.out.println(form.format(p));//(0.2360后面的0省略)  0.236

其他零碎知识点

  1. 正则表达式

str.replaceAll(“6{10,}”, “27”).replaceAll(“6{4,}”, “9”)

// 6出现10次及以上替换为27，出现四次及以上替换为9

  1. 转义字符
        // 换行System.out.println("Hello\nWorld");  
//Hello
//World// 制表符System.out.println("Hello\tWorld");
//Hello        World// 退格System.out.println("Hello\bWorld");
//HelloWorld// 回车System.out.println("Hello\rWorld");//Hello
//World// 单引号和双引号System.out.println("She said: \"Hello, World!\"");System.out.println("It's a sunny day.");
//She said: "Hello, World!"
//It's a sunny day.// 反斜杠自身System.out.println("This is a backslash: \\");//This is a backslash: \// 在正则表达式中，需要使用两个反斜杠来转义一些特殊字符。// 例如，正则表达式中的 \( 表示 (   而 \\( 表示 \(// replaceAll 方法使用正则表达式来替换字符串中的匹配项String commend = "(al)G(al)()()G";String s = command.replaceAll("\\(\\)","o").replaceAll("\\(al\\)","al");System.out.println(s);

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/255408.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

使用耳机壳UV树脂制作一个耳机壳需要多长时间？

使用耳机壳UV树脂制作一个耳机壳需要多长时间？

使用耳机壳UV树脂制作一个耳机壳所需的时间取决于多个因素&#xff0c;包括工艺流程、加工方式、设备和技术水平等。一般来说&#xff0c;制作一个耳机壳需要数小时到数天不等。 以下是影响制作时间的几个主要因素&#xff1a; 获取耳模时间&#xff1a;获取耳模的时间取决于…
阅读更多...
数据库学习案例20240206-ORACLE NEW RAC agent and resource关系汇总。

数据库学习案例20240206-ORACLE NEW RAC agent and resource关系汇总。

1 集群架构图 整体集群架构图如下&#xff1a; 1 数据库启动顺序OHASD层面 操作系统进程init.ohasd run启动ohasd.bin init.ohasd run 集群自动启动是否被禁用 crsctl enable has/crsGIHOME所在文件系统是否被正常挂载。管道文件npohasd是否能够被访问&#xff0c; cd /var/t…
阅读更多...
口腔助手|口腔挂号预约小程序|基于微信小程序的口腔门诊预约系统的设计与实现(源码+数据库+文档)

口腔助手|口腔挂号预约小程序|基于微信小程序的口腔门诊预约系统的设计与实现(源码+数据库+文档)

口腔小程序目录 目录 基于微信小程序的口腔门诊预约系统的设计与实现 一、前言 二、系统功能设计 三、系统实现 1、小程序前台界面实现 2、后台管理员模块实现 四、数据库设计 1、实体ER图 2、具体的表设计如下所示&#xff1a; 五、核心代码 六、论文参考 七、最新…
阅读更多...
Spark安装（Yarn模式）

Spark安装（Yarn模式）

一、解压 链接&#xff1a;https://pan.baidu.com/s/1O8u1SEuLOQv2Yietea_Uxg 提取码&#xff1a;mb4h tar -zxvf /opt/software/spark-3.0.3-bin-hadoop3.2.tgz -C /opt/module/spark-yarn mv spark-3.0.3-bin-hadoop3.2/ spark-yarn 二、配置环境变量 vim /etc/profile…
阅读更多...
空气质量预测 | Matlab实现基于SVR支持向量机回归的空气质量预测模型

空气质量预测 | Matlab实现基于SVR支持向量机回归的空气质量预测模型

文章目录 效果一览文章概述源码设计参考资料效果一览 文章概述 政府机构使用空气质量指数 (AQI) 向公众传达当前空气污染程度或预测空气污染程度。 随着 AQI 的上升，公共卫生风险也会增加。 不同国家有自己的空气质量指数，对应不同国家的空气质量标准。 基于支持向量机（Su…
阅读更多...
【MATLAB源码-第138期】基于matlab的D2D蜂窝通信仿真，对比启发式算法，最优化算法和随机算法的性能。

【MATLAB源码-第138期】基于matlab的D2D蜂窝通信仿真，对比启发式算法，最优化算法和随机算法的性能。

操作环境&#xff1a; MATLAB 2022a 1、算法描述 D2D蜂窝通信介绍 D2D蜂窝通信允许在同一蜂窝网络覆盖区域内的终端设备直接相互通信&#xff0c;而无需数据经过基站或网络核心部分转发。这种通信模式具有几个显著优点&#xff1a;首先&#xff0c;它可以显著降低通信延迟&…
阅读更多...
Day30 回溯算法part06

Day30 回溯算法part06

又是眼红别人的一天 重新安排行程 菜鸡思路&#xff1a;把从jfk往下所有的情况都列举出来&#xff0c;result数组包含五个元素的时候返回数组。 我们只需要找到一个行程&#xff0c;就是在树形结构中唯一的一条通向叶子节点的路线 N皇后 这个isValid函数也很不好想啊 首先…
阅读更多...
seata分布式事务

seata分布式事务

文章目录 1、分布式事务1.1 事务的ACID原则原子性一致性隔离性持久性 1.2 分布式事务的问题示例代码准备环境1. seata_demo数据库2. 启动nacos seata-demo父工程pom.xml order-servicepom.xmlapplication.ymlOrderApplicationOrderControllerOrderServiceImplAccountClientStor…
阅读更多...
Elasticsearch：通过 ingest pipeline 对大型文档进行分块

Elasticsearch：通过 ingest pipeline 对大型文档进行分块

在我之前的文章 “Elasticsearch&#xff1a;使用 LangChain 文档拆分器进行文档分块” 中&#xff0c;我详述了如何通过 LangChain 对大的文档进行分块。那个分块的动作是通过 LangChain 在 Python 中进行实现的。对于使用版权的开发者来说&#xff0c;我们实际上是可以通过 i…
阅读更多...
【大厂AI课学习笔记】【1.6 人工智能基础知识】（1）人工智能、机器学习、深度学习之间的关系

【大厂AI课学习笔记】【1.6 人工智能基础知识】（1）人工智能、机器学习、深度学习之间的关系

6.1 人工智能、机器学习与深度学习的关系 必须要掌握的内容&#xff1a; 如上图&#xff1a;人工智能>机器学习>深度学习。 机器学习是人工智能的一个分支&#xff0c;该领域的主要研究对象是人工智能&#xff0c;特别是如何在经验学习中改进具体算法的性能。 深度学习…
阅读更多...
TCP 传输控制协议——详细

TCP 传输控制协议——详细

目录 1 TCP 1.1 TCP 最主要的特点 1.2 TCP 的连接 TCP 连接&#xff0c;IP 地址&#xff0c;套接字 1.3 可靠传输的工作原理 1.3.1 停止等待协议 &#xff08;1&#xff09;无差错情况 &#xff08;2&#xff09;出现差错 &#xff08;3&#xff09;确认丢失和确认迟到…
阅读更多...
【linux系统体验】-archlinux折腾日记

【linux系统体验】-archlinux折腾日记

archlinux 一、系统安装二、系统配置及美化2.1 中文输入法2.2 安装virtualbox增强工具2.3 终端美化2.4 桌面面板美化 三、问题总结3.1 一、系统安装 安装步骤人们已经总结了很多很全: Arch Linux图文安装教程 大体步骤&#xff1a; 磁盘分区安装 Linux内核配置系统&#xff…
阅读更多...
redis双写一致

redis双写一致

redis双写一致&#xff0c;指的是redis缓存与mysql数据同步 双写一致常见方案有很多&#xff1a; 同步双写&#xff1a;更新完mysql后立即同时更新redis mq同步&#xff1a;程序在更新完mysql后&#xff0c;投递消息到中间键mq&#xff0c;一个程序监听mq&#xff0c;获得消…
阅读更多...
基于Springboot的足球社区管理系统（有报告）。Javaee项目，springboot项目。

基于Springboot的足球社区管理系统（有报告）。Javaee项目，springboot项目。

演示视频&#xff1a; 基于Springboot的足球社区管理系统&#xff08;有报告&#xff09;。Javaee项目&#xff0c;springboot项目。 项目介绍&#xff1a; 采用M&#xff08;model&#xff09;V&#xff08;view&#xff09;C&#xff08;controller&#xff09;三层体系结构…
阅读更多...
电力负荷预测 | Matlab实现基于LSTM长短期记忆神经网络的电力负荷预测模型（结合时间序列）

电力负荷预测 | Matlab实现基于LSTM长短期记忆神经网络的电力负荷预测模型（结合时间序列）

文章目录 效果一览文章概述源码设计参考资料效果一览 文章概述 电力负荷预测 | Matlab实现基于LSTM长短期记忆神经网络的电力负荷预测模型（结合时间序列） 所谓预测，就是指通过对事物进行分析及研究，并运用合理的方法探索事物的发展变化规律，对其未来发展做出预先估计和判断…
阅读更多...
【漏洞复现】狮子鱼CMS某SQL注入漏洞01

【漏洞复现】狮子鱼CMS某SQL注入漏洞01

Nx01 产品简介 狮子鱼CMS&#xff08;Content Management System&#xff09;是一种网站管理系统&#xff0c;它旨在帮助用户更轻松地创建和管理网站。该系统拥有用户友好的界面和丰富的功能&#xff0c;包括页面管理、博客、新闻、产品展示等。通过简单直观的管理界面&#xf…
阅读更多...
Ubuntu22.04 gnome-builder gnome C 应用程序习练笔记(三)

Ubuntu22.04 gnome-builder gnome C 应用程序习练笔记(三)

八、ui窗体创建要点 .h文件定义(popwindowf.h)&#xff0c; TEST_TYPE_WINDOW宏是要创建的窗口样式。 #pragma once #include <gtk/gtk.h> G_BEGIN_DECLS #define TEST_TYPE_WINDOW (test_window_get_type()) G_DECLARE_FINAL_TYPE (TestWindow, test_window, TEST, WI…
阅读更多...
c++之说_10|自定义类型 union 联合体

c++之说_10|自定义类型 union 联合体

之前我们说了一些 struct 结构体 现在来了解新的自定义类型 union 联合体 语法 union ptr {void* fptr;CLassFunPtr p;FunPtr p2;ptr& operator(CLassFunPtr ptr){p ptr;return *this;}ptr& operator(FunPtr Fptr){p2 Fptr;return *this;} } FunPtr_; 我们看到了…
阅读更多...
【Effective Objective - C 2.0】——读书笔记（二）

【Effective Objective - C 2.0】——读书笔记（二）

文章目录 前言六、理解“属性”这一概念七、在对象内部尽量直接访问实例变量八、理解“对象等同性”这一概念九、以“类族模式”隐藏实现细节十、在既有类中使用关联对象存放自定义数据十一、理解objc_msgSend的作用十二、理解消息转发机制动态方法解析备援接受者完整的消息转发…
阅读更多...
Hive-架构与设计

Hive-架构与设计

架构与设计 一、背景和起源二、框架概述1.设计特点 三、架构图1.UI交互层2.Driver驱动层3.Compiler4.Metastore5.Execution Engine 四、执行流程1.发起请求2.获取执行计划3.获取元数据4.返回元数据5.返回执行计划6.运行执行计划7.运行结果获取 五、数据模型1.DataBase数据库2.T…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023