Java基础
1.Object类
import java.util.Objects;
public class Object01 {
public static void main(String[] args) throws CloneNotSupportedException{
/*
TODO 方法：
clone() => 创建并返回此对象的副本 (浅拷贝)
equals => 判断两个对象是否相等
equals 默认底层使用 == 对两个对象地址进行判断，如果地址相同，那么结果为true
hashCode() => 返回对象的Hash值，该函数是一个映射函数 传入一个值，肯定有一个唯一对应的随机的值
toString() => 用于将当前对象转换成一个字符串
getClass() => 获取当前对象的类路径
*/
Object object = new Object();
String objStr = object.toString();
System.out.println(objStr); // java.lang.Object@4554617c
System.out.println(object); // java.lang.Object@4554617c println就是调用了 toString 方法
String str = new String("这是一个字符串");
System.out.println(str.toString()); // 子类可以重写toString 方法
MyClass myClass1 = new MyClass("toString", "这是一个自定义类");
MyClass myClass2 = new MyClass("toString", "这是一个自定义类");
System.out.println(myClass1);
System.out.println(myClass1.equals(myClass2)); // true
// TODO 在Java中Class也是一个类 该类的对象表示 类对象
Class aClass = myClass1.getClass();
System.out.println(aClass.getName().toString()); // 获取当前对象的类路径
//结果： com.shujia.Day07_Object_StringFunction_WrapClass.MyClass
}
}
/*
对于一个自定义类，如果该类用于表述数据 那么其规范的写法：
比如对于 Mysql中的emp表 每一行数据代表是一个员工类 员工的字段是类中的属性
*/
class MyClass{
private String name;
private String data;
public MyClass(String name, String data) {
this.name = name;
this.data = data;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
//equals()方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MyClass myClass = (MyClass) o;
return Objects.equals(name, myClass.name) && Objects.equals(data, myClass.data);
}
//重写hashCode()方法
@Override
public int hashCode() {
return Objects.hash(name, data);
}
/*
TODO 对于外部获取当前类对象的信息时，一般会调用toString方法
对于继承的toString方法 不能获取其属性信息 所以需要对其进行重写
*/
@Override
public String toString() {
return "MyClass{" +
"name='" + name + '\'' +
", data='" + data + '\'' +
'}';
}
}
2.Scanner类
import java.io.InputStream;
import java.util.Scanner;
public class ScannerClass {
public static void main(String[] args) {
/*
TODO Scanner类
*/
/*
TODO 想要从控制台获取数据 => System.in
in 是 System中的一个属性 类别为 InputStream 称为输入流
*/
InputStream inputStream = System.in;
Scanner scanner = new Scanner(inputStream);
/*
TODO
next()一定要读取到有效字符后才可以结束输入，对输入有效字符之前遇到的空格键、
Tab键或Enter键等结束符，next()方法会自动将其去掉，只有在输入有效字符之后，
next()方法才将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符。
nextLine()方法的结束符只是Enter键，
即nextLine()方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的。
*/
// String next = scanner.next();
String next = scanner.nextLine();
System.out.println(next+"|");
}
}
3.String类
public class StringClass {
public static void main(String[] args) {
/*
TODO String类
*/
String str1 = "String";
String str2 = "String";
String newStr = new String("String");
System.out.println(str1 == str2); // true => 内存地址一样
System.out.println(str1 == newStr); // false => == 用于判断内存地址是否相同 内存地址不一样
System.out.println(str1.equals(newStr)); // true => equals是比较具体的数据(String类中的equals()方法经过了重写，判断值是否相等)
String str3 = "1+1=2";
String str4 = "1+1=";
String str5 = "2";
String str6 = str4 + str5; // 通过 + 的方式得到的结果，会在堆空间中保存数据
System.out.println(str3 == str6); // false str3会存放到栈空间中
}
}
4.String方法01
public class StringFunction01 {
public static void main(String[] args) {
/*
TODO String类的方法
1.构造方法
new String(char[] chars)
new String(byte[] bytes)
2.判断功能
boolean equals(Object obj) 等值判断 // 非常重要
boolean equalsIgnoreCase(String str) // 忽略大小写比较字符串
boolean contains(String str) // 是否包含某个子字符串
boolean startsWith(String str) // 判断是否以某个子字符串为开头
boolean endsWith(String str) // 判断是否以某个子字符串为结尾
boolean isEmpty() //判断字符串是否为空
3.String类的获取功能
int length() => 获取字符长度 // 非常重要
char charAt(int index) => 根据下标获取其对应下标位置上的数据 => 因为字符串可以看成是char类型的数组
int indexOf(int ch) indexOf是用于返回其传入 参数(注意参数列表) 在字符串中的下标
int indexOf(String str)
int indexOf(int ch,int fromIndex)
int indexOf(String str,int fromIndex) fromIndex 表示从某个下标开始寻找
String substring(int start) // 非常重要 从某个开始下标截取字符串直到末尾
String substring(int start,int end) // 非常重要 从某个开始下标截取字符串直到结束下标 截取区间为左闭右开区间
*/
char[] chars = {'a','b','c','d'};
String char2Str = new String(chars);
System.out.println(char2Str); // print()方法内部调用了toString()方法，因此可以这样输出
// TODO 对于字符串来说 认为byte[]中保存的数据是字节数据，在创建对象时，会根据其ASC码值将其转换成对应的字符
byte[] bytes = {97,98,99};
System.out.println(new String(bytes)); // abc
String str = "ABCD";
System.out.println(char2Str.equalsIgnoreCase(str)); // true
System.out.println(char2Str.contains("a")); // true
System.out.println(str.startsWith("AB")); // true
System.out.println(str.endsWith("CD")); // true
System.out.println(str.isEmpty()); //
// 对字符串赋予 null 值之后，使得其指向的内地址消失 所以调用时会出现空指针异常
// String nullStr = null;
//注：null与""是两个概念，isEmpty()输出不同
String emptyStr = "";
// System.out.println(nullStr.isEmpty()); // java.lang.NullPointerException
System.out.println(emptyStr.isEmpty()); // true
System.out.println(str.length()); // 4
System.out.println(str.charAt(0));
System.out.println(str.indexOf("BC")); // 1 返回的是第一个字符的下标
String str2 = "ABCDABCD";
System.out.println(str2.indexOf("BC",2)); // 5 从第二个字符开始查找，并返回下标
System.out.println(str2.substring(2)); // CDABCD
System.out.println(str2.substring(2,6)); // CDAB
}
}
5.String方法02
import java.util.Arrays;
public class Demo05StringFunction2 {
public static void main(String[] args) {
/*
TODO 字符串方法
转换功能
byte[] getBytes() （若无参数）表示使用平台的默认字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
char[] toCharArray() 将字符串中的字符转换为字符数组
static String valueOf(char[] chs) 将 char 数组 data 转换成字符串
static String valueOf(int i) 将 int 变量 i 转换成字符串
String toLowerCase() 将字符串中字符转换成大写
String toUpperCase() 将字符串中字符转换成小写
String concat(String str) 用于将指定的字符串参数连接到字符串上
*/
String str = "abcd";
byte[] bytes = str.getBytes();
System.out.println(Arrays.toString(bytes)); // [97, 98, 99, 100]
/*TODO
注：对于一个中文默认占用三个字节数据
*/
String str2 = "字符串"; // => [-27, -83, -105, -25, -84, -90, -28, -72, -78]
System.out.println(Arrays.toString(str2.getBytes()));
/*TODO
注：对于一个中文默认占用一个字符数据
*/
char[] chars = str2.toCharArray();
System.out.println(Arrays.toString(chars));
System.out.println(str.toCharArray());
char[] chars2 = {'数','组'};
/* TODO:
String.valueOf(char[] data) : 将 char 数组 data 转换成字符串
String.valueOf(char[] data, int offset, int count) :
将 char 数组 data 中 由 data[offset] 开始取 count 个元素 转换成字符串
*/
String char2Str = String.valueOf(chars2);
System.out.println(char2Str);
System.out.println(str.toUpperCase());
System.out.println(str.toUpperCase().toLowerCase());
// 如何将hello转换成Hello
String hello = "helLo"; // => Hello
String takeStr = hello.substring(1).toLowerCase();
// String headStr = hello.substring(0, 1).toUpperCase();
String headStr = String.valueOf(hello.charAt(0)).toUpperCase();
System.out.println(headStr+takeStr);
String str3 = "head";
String str4 = "tail";
System.out.println(str3+","+str4);
System.out.println(str3.concat(",").concat(str4));
}
}
6.String方法03
package com.shujia.Day07_Object_StringFunction_WrapClass;
import java.util.Arrays;
public class Demo06StringFunction3 {
public static void main(String[] args) {
/*
TODO String类的其他功能
String replace(char old,char new)
String replace(String old,String new) // 非常重要
String trim() 去除前后空格信息
字典顺序比较：(字典顺序指的是ASCII码表中的字符顺序。ASCII表中每个字符都有对应的下标，从0开始升序排列，共128个字符。)
int compareTo(String str)：
用字符串1跟字符串2作比较（字符串1.compareTo(字符串2)），如果字符串1的字典顺序在字符串2前面，
则返回一个正数。若在后面，则返回一个负数。若两个字符串的字典顺序相同，则返回0。
特殊案例：
String str1 = "ljj";
String str2 = "ljjLovexql";
System.out.println(str1.compareTo(str2));
以上代码运行结果为 -7，str1比str2少7个字符，所以返回 -7
int compareToIgnoreCase(String str) 方法用于按字典顺序比较两个字符串，不考虑大小写
注意：对于String中修改数据的函数，不会对String本身进行修改，会返回一个新的String对象
*/
String str = "123 456";
System.out.println(str.replace(" ", ","));
System.out.println(str);
String str1 = " 今天天气真好呀 \t";
System.out.println(str1);
System.out.println(str1.trim()+"|");
// 对于数值数据进行排序时，是按照自然排序方式
int[] ints = {11,10,100};
Arrays.sort(ints);
System.out.println(Arrays.toString(ints)); // [10, 11, 100]
// 对于字符串类型数据进行比较时，是按照字典顺序进行比较的
String strArr[] = {"11","10","100"};
Arrays.sort(strArr);
System.out.println(Arrays.toString(strArr)); // [10, 100, 11]
String intStr1 = "11";
String intStr2 = "100";
int compareToRes = intStr1.compareTo(intStr2); // 1
System.out.println(compareToRes);
/*
value?
private final char value[]; => 11
value = ['1','1']
public int compareTo(String anotherString) {
int len1 = value.length; ['1','1'] => 2
int len2 = anotherString.value.length; ['1','0','0'] => 3
int lim = Math.min(len1, len2); // 取长度最小值 2
char v1[] = value; ['1','1']
char v2[] = anotherString.value; ['1','0','0']
int k = 0; // 下标
while (k < lim) {
// 取出对应下标中的字符
char c1 = v1[k];
char c2 = v2[k];
// k=1 => c1=1,c2=0
if (c1 != c2) {
// 将两个char类型的数据通过ASC码值进行比较 返回其差值
// c1表示当前字符串 c2表示传入比较的字符串
return c1 - c2;
}
k++;
}
return len1 - len2;
}
*/
//实现字符串abc的逆序输出
String str4 = "abc";
String res = "";
char[] chars = str4.toCharArray();
for (int i = chars.length-1; i >= 0 ; i--) {
res += chars[i];
}
System.out.println(res);
//从下方字符串中匹配”java“的数量
String javaStr = "oaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
//TODO 法一：
// int num = 0;
// for (int i = 0; i < javaStr.length(); i++) {
// if (i + 4 < javaStr.length()){
// String substring = javaStr.substring(i, i + 4);
// if (substring.equals("java")) {
// num ++;
// }
// }
// }
// System.out.println("num:"+num);
int num = 0;
// TODO 法二：
// while (javaStr.contains("java")){
// 返回下标
// int javaStartIndex = javaStr.indexOf("java");
// 进行javaStartIndex+4，越过此次找到的“java”来进行下一次的查找
// javaStr = javaStr.substring(javaStartIndex+4);
// num ++;
// }
// System.out.println("num:"+num);
// TODO 法三(相对于法二进行了优化)： indexOf当获取不到值对应返回结果为 -1
// javaStr = "hello";
// System.out.println(javaStr.indexOf("java"));
int javaStartIndex = 0;
while ((javaStartIndex = javaStr.indexOf("java")) != -1){
javaStr = javaStr.substring(javaStartIndex+4);
num ++;
}
System.out.println("num:"+num);
// 当前String类型的字符长度是不可更改的 => 字符串底层做数据存储是 char[] 定义后长度不可发生变化
String st = "a";
String b = st.concat("b");
System.out.println(b);
}
}
![【Hadoop】-Hive部署[12]](https://img-blog.csdnimg.cn/direct/7b640b8b7b574589ba766555d2e31763.png)
