1. Introdução
Caros amigos, o que estamos vendo agora é uma nova API parcial da parte básica do Java. O que é e o que ela pode fazer? Na verdade, pode ser resumida em uma frase: ajude-nos a ficar nos ombros de gigantes
e alcançar um desenvolvimento mais eficiente, então vamos descobrir ~
2 O que é uma API
API (Application Programming Interface, interface de programação de aplicativos) é algumas funções predefinidas. O objetivo é fornecer um conjunto de funções que aplicativos e desenvolvedores possam acessar com base em um determinado software, mas sem acesso ao código-fonte ou compreensão dos detalhes do mecanismo interno de trabalho. A API é um conjunto geral de funções e, às vezes, as
empresas usam a API como seu sistema público aberto, ou seja, a empresa formula seu próprio padrão de interface do sistema. Quando operações como integração do sistema, personalização e aplicação do programa são necessárias, todos os membros da empresa podem chamar o código fonte por meio desse padrão .
O pacote Java.util é um kit de ferramentas em java, incluindo várias classes de utilitários/classes de coleção/ferramentas de data e hora e outros kits de ferramentas comumente usados
import
java.util.Scanner;
O pacote java.lang é o núcleo do java, incluindo as classes básicas de java, incluindo as classes mais básicas, como classe básica de objeto/classe de classe/classe de string/classe matemática básica. Este pacote não precisa ser importado e importar java.lang.Object
é automaticamente importado por padrão; import java.lang.String; import java.lang.StringBuilder/StringBuffer;
expressão regular
Classes wrapper e muito mais –
Em seguida, aprenderemos algumas classes comumente usadas para ajudá-lo a concluir o "projeto de infraestrutura". Em primeiro lugar, o primeiro jogador é a lendária classe Object
3 objeto
3.1 Conceito
A classe Object é a ancestral de todas as classes Java, ou seja, o que chamamos de "classe pai de nível superior"
existe em java.lang.Object. Este pacote não exige que guiemos manualmente o pacote
. Deve-se notar que cada classe usa Object como uma superclasse. Todos os objetos (incluindo arrays) implementam os métodos desta classe.
Se a superclasse não for fornecida explicitamente, Java usará automaticamente a classe Object como a superclasse da classe a ser definida.
3.2 Introdução aos métodos comuns
toString()
Este método é usado para retornar a representação de string do objeto correspondente
hashCode()
Este método
é usado para retornar o valor do código hash dos objetos objetos correspondentes.
Mas às vezes há casos especiais em que objetos diferentes têm o mesmo valor de código hash, que chamamos de fenômeno de "colisão de hash"
equals()
Este método é usado para indicar se outro objeto é "igual" ao objeto atual
3.3 Exercício: Exercício de classe de objeto
Criar pacote: cn.tedu.api
Criar classe: TestObject.java
package cn.tedu.api;
import java.util.Objects;
/*本类用于顶级父类Object的入门案例*/
//1.查API手册
//2.连点两下Shift打开IDEA的搜索,注意勾选"include non-Project items",再搜Object
//3.按住Ctrl点hashCode()
//4.在拓展库External Libraries找到jdk1.8->rt.jar->java.lang.Object
public class TestObject {
public static void main(String[] args) {
//4.创建学生类的对象做测试
Student s = new Student();
Student s1 = new Student("海绵宝宝",3);
Student s2 = new Student("海绵宝宝",3);
//5.测试hashCode()
/*本方法的作用是返回对应对象的int类型的哈希码值
* 本方法力求不同的对象返回的哈希码不同
* 这样我们就可以根据哈希值区分不同的对象*/
System.out.println(s.hashCode());
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
//6.测试toString()
//打印s对象的是println(),这个方法会层层调用，一直到Object中的toString()
/*Object中toString()的默认实现：对象的名字@十六进制的哈希码值
* 子类重写了toString()以后：打印是对象的类型+属性+属性值*/
//return getClass().getName() + "@" + Integer.toHexString(hashCode());
System.out.println(s);
System.out.println(s1);
// 8.测试equals()
/*Object中equals()的默认实现使用的是==比较
* ==比较的是左右两边的值,如果是基本类型,比较的就是字面值,比如1和1,3.4和3.4
* 如果是引用类型,比较的是引用类型变量保存的地址值
* 子类重写了equals()与hashCode()以后,比较的就是对象的类型+属性+属性值*/
System.out.println(s1.equals(s2));//false
System.out.println(s.equals(s1));
}
}
//1.创建一个学生类
class Student{
//2.定义属性
String name;//姓名
int age;//年龄
//3.1添加本类的无参构造
public Student() {
System.out.println("无参构造");
}
//3.2添加本类的全参构造
public Student(String name, int age) {
this.name = name;
this.age = age;
System.out.println("全参构造");
}
//7.在Student类中添加重写的toString()
//右键->Generate->toString
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//9.添加重写的equals与hashCode()
/*equals()与hashCode()逻辑要保持一致,要重写都重写,要不重写,都不重写
* Object默认实现:hashCode()的哈希码值根据地址值生成
* equals()底层使用==比较两个对象的地址值
* Student类重写后:hashCode()的哈希码值根据重写后传入的对象的属性生成
* equals()比较两个对象的类型+所有属性与属性值
* */
@Override
public boolean equals(Object o) {
//前提：this代表的是调用本方法对象s1 o代表的是传入的对象s2
//1.比较的是两个对象的地址值,如果==为true,证明直接就是同一个对象
//后续就不用比较了，直接返回true
if (this == o) return true;
//2.1如果传入的对象是null，说明实际上并没有对象，还是引用类型的默认值
//2.2如果两个对象获取类型不一致，比如一个是Cat类型，一个是Car类型
//以上两种情况只要满足任意一种，不符合条件，直接返回false
if (o == null || getClass() != o.getClass()) return false;
//3.传入对象的类型是Object,父类无法使用子类的特有属性，所以需要强转
/*多态：向上造型：把子类型看作是父类型，花木兰替父从军 Animal a = new Cat();
向下造型：之前转成父类型的子类对象，又想使用子类自己的特有功能了，可以向下转型
写法：Cat c = (Cat) a; 比如花木兰打仗完了想用自己的特有功能：化妆*/
//向下造型：把父类型Object转回子类型Student
Student student = (Student) o;
//4.比较的是两个对象的属性与属性值
//如果是基本类型，直接比较值，所以用==比较
//如果是引用类型，比如String,还需要使用bjects.equals()做比较
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
//重写后根据属性生成
return Objects.hash(name, age);
}
}
4 cordas
4.1 Características
String é um objeto que encapsula um array char[], e a string é imutável Como
pode ser visto na implementação subjacente na figura abaixo: é modificado por final e é uma constante
String str = "abc"; equivalente a : char dados[] = {'a', 'b', 'c'};
4.2 Formas de criar objetos String
Método 1:
String(char[] value) Aloca uma nova String para representar a sequência de caracteres atualmente contida no parâmetro de matriz de caracteres.
Método 2: String str = "abc";
Se a string for usada pela primeira vez, o java criará um objeto no conjunto de constantes na pilha de strings.
Quando o mesmo conteúdo é usado novamente, o objeto presente no pool de constantes no heap é acessado diretamente.
4.3 Métodos comuns
String API Summary
int hashCode() Retorna o código hash para esta string.
boolean equals(Object anObject) Compara esta string com o objeto especificado, comparando o conteúdo específico da string reescrita
String toString() Retorna o próprio objeto (já é uma string!).
int length() Retorna o comprimento desta string.
String toUpperCase() Todos os caracteres são convertidos em maiúsculas.
String toLowerCase() Todos os caracteres são convertidos em letras minúsculas
booleanas startsWith(String prefix) Testa se esta string começa com o elemento especificado.
boolean endsWith(String sufixo) Testa se esta string termina com a string especificada.
char charAt(int index) retorna o valor char/caractere no índice/subscrito especificado
int indexOf(String str) retorna o índice da primeira ocorrência do caractere especificado nesta string.
int lastIndexOf(String str) Retorna o índice da última ocorrência do caractere especificado nesta string.
String concat(String str) Concatena/junta a string especificada ao final desta string, nota: a string original não será alterada
String[] split(String regex) Separa esta string de acordo com os elementos dados.
String trim() Retorna a string byte[] com os espaços à esquerda e à direita removidos
GetBytes() Armazena a string em uma nova matriz de bytes
String substring(int beginIndex) Retorna uma nova substring, começando do subscrito especificado, incluindo o subscrito especificado Subscrito
String substring(int beginIndex, int endIndex) retorna uma nova substring, começando do subscrito de execução até o subscrito final, mas não incluindo o subscrito final static
String valueOf(int i) Converter int em String
4.4 Exercício: prática do método comum de cordas
Criar pacote: cn.tedu.api
Criar classe: TestString.java
package cn.tedu.api;
/*本类用于练习String类的使用*/
public class TestString {
public static void main(String[] args) {
//1.创建String的方式一
/*1.字符串类型底层维护的是char[]，存在堆中*/
char[] value = {
'a','b','c'};
String s1 = new String(value);//触发String(char[])的含参构造来创建对象
String s11 = new String(value);//触发String(char[])的含参构造来创建对象
//2.创建String的方式二
String s2 = "abc";
String s22 = "abc";
String s3 = "ccc";
//3.测试
System.out.println(s1 == s2);//false，一个在堆里，一个在堆中常量池
System.out.println(s1 == s11);//false,两个不同的对象，地址值不同
System.out.println(s2 == s22);//true，都在堆中常量池，并且指向同一个，所以地址值相同
System.out.println(s2 == s3);//false，都在堆中常量池，但是数据不同，指向两个地址
/*Object类中equals()的默认实现是通过==来比较的。
但是String类已经重写过了继承自Object中的equals()
重写后，不再按照==比较，而是比较两个字符串的具体内容
也就是说，不论创建方式，只要是串的内容一致，equals()就返回true
* */
System.out.println(s1.equals(s2));//true
System.out.println(s1.equals(s11));//true
System.out.println(s2.equals(s3));//false
}
}
Criar pacote: cn.tedu.api
Criar classe: TestString2.java
package cn.tedu.api;
import java.util.Arrays;
/*本类用来测试String类的常用方法*/
public class TestString2 {
public static void main(String[] args) {
//1.创建字符串
String s1 = "abc";
char[] values = {
'a','b','c'};
String s2 = new String(values);
//2.测试常用方法
/*String重写了hashCode(),是根据字符串的内容生成哈希码值，而不是根据地址值生成
* 所以虽然s1与s2一个在堆的常量池中，一个在堆中，它两的哈希码值一样*/
System.out.println(s1.hashCode());//96354
System.out.println(s2.hashCode());//96354
System.out.println(s1.equals(s2));//true,重写了，比较的是具体内容
System.out.println(s1.toString());//不需要写，底层会自动调用s1对象的toString()
System.out.println(s1);//abc,String重写了toString(),直接打印的是串的具体内容
System.out.println(s1.length());//3,查看当前字符串的长度
System.out.println(s1.toUpperCase());//ABC,将本字符串转为全大写
System.out.println(s1.toLowerCase());//abc,将本字符串转为全小写
System.out.println(s1.startsWith("a"));//true,判断本字符串是否以指定元素a开头
System.out.println(s2.endsWith("a"));//false,判断本字符串是否以指定元素a结尾
System.out.println(s1.charAt(0));//a,根据下标获取本字符串中对应的元素
String s3 = "abcbdbba";
System.out.println(s3.indexOf("b"));//1,返回本字符串中指定元素第一次出现的下标
System.out.println(s3.lastIndexOf("b"));//6,返回本字符串中指定元素最后一次出现的下标
System.out.println(s2.concat("cxy"));//abccxy,将指定字符串拼接到本字符串的结尾
System.out.println(s2);//abc,说明上面的拼接是临时的，不会改变原串的内容
String s4 = s2.concat("aaa");//如果想要多次使用拼接后的结果，需要定义一个字符串来保存结果
System.out.println(s4);//abcaaa
String s5 = "afbfcfdfe";
//返回值类型是String[],所以需要使用Arrays.toString()打印
//以指定字符作为分割符，分割当前的字符串
//我们只是直接打印了split()的结果，没有使用变量保存
System.out.println(Arrays.toString(s5.split("f")));//[a, b, c, d, e]
//由于split()的返回值类型是String[],所以我们执行这个方法，可以拿到这个方法的返回值
//所以a数组就是这个方法执行以后得到的结果，只不过我们保存下来了
String[] a = s5.split("f");
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
String s6 = " hh hhh ";//去除本字符串首尾两端的空格
System.out.println(s6.trim());//hh hhh
String s7 = "abcdefgh";
System.out.println(s7.substring(3));//defgh,从指定下标处截取子字符串[3,结束]
System.out.println(s7.substring(3,6));//def,从指定下标处截取子字符串[3,6)含头不含尾
System.out.println(String.valueOf(10));//10,将int类型的参数10转为String类型
System.out.println("20"+10);//2010,String与int拼接
System.out.println(20+10);//30，int与int相加
System.out.println(String.valueOf(80)+10);//8010,将int类型的参数80转为String类型，所以拼接
byte[] bs = s7.getBytes();//将指定字符串转为byte[]
}
}
5 StringBuilder/StringBuffer
5.1 Recursos
Ele encapsula o array char[]
, que é uma sequência de caracteres variáveis,
e fornece um conjunto de métodos que podem modificar o conteúdo dos caracteres.
Append() é frequentemente usado em vez de strings para concatenação de strings. "+"
O padrão capacidade inicial do array interno de caracteres é 16: super (str.length() + 16);
Se for maior que 16, tentará expandir o tamanho do novo array. O tamanho original do novo array passa a ser 2 vezes + 2. Se a capacidade não for suficiente, ela será expandida diretamente para a capacidade necessária. int newCapacity = value.length * 2 + 2;
StringBuffer 1.0 é thread-safe, mas StringBuilder 1.5 não é thread-safe
5.2 Métodos comuns
acrescentar()
5.3 Exercício 3: Teste de concatenação de strings
Criar pacote: cn.tedu.api
Criar classe: TestString3.java
package cn.tedu.api;
/*本类用于测试字符串的拼接*/
public class TestString3 {
public static void main(String[] args) {
//需求：将26个字母拼接10000次
String s = "abcdefghijklmnopqrstuvwxyz";
//method1(s);//使用方式一拼接字符串
method2(s);//使用方式二拼接字符串
}
//使用方式二拼接字符串
private static void method2(String s) {
//1.创建工具类对象
StringBuffer sb = new StringBuffer();
StringBuilder sb2 = new StringBuilder();
//5.添加一个计时的功能
//5.1拼接之前获取系统当前时间作为开始时间
long t1 = System.currentTimeMillis();
//2.拼接10000次
for (int i = 0; i < 10000; i++) {
//3.使用工具类对象的append()进行拼接
//sb.append(s);
sb2.append(s);
}
//5.2拼接之后获取系统当前时间作为结束时间
long t2 = System.currentTimeMillis();
//4.打印拼接的效果
//System.out.println(sb);
System.out.println(sb2);
//5.3打印拼接总共消耗的时间
System.out.println(t2-t1);
}
//使用方式一完成字符串的拼接
private static void method1(String s) {
//1.创建一个变量用来保存拼接后的效果
String result = "";
//5.给程序添加一个计时的功能
//5.1获取循环开始的系统当前时间
long t1 = System.currentTimeMillis();
//2.创建循环执行10000次
for (int i = 0; i < 10000; i++) {
//3.进行字符串的拼接
result = result + s;
}
//5.2获取循环拼接之后的系统当前时间
long t2 = System.currentTimeMillis();
//4.打印拼接后的效果
System.out.println(result);
//5.打印花费的时间
System.out.println(t2-t1);
System.out.println(t2);
}
}
6 expansão
6.1 A diferença entre iguais e iguais
1. Ao usar == comparação, se as duas variáveis sendo comparadas são tipos de referência, então o valor físico (endereço de memória) dos dois é comparado, e se as duas variáveis sendo comparadas são todas do tipo valores , então a comparação é se os valores específicos são iguais.
2. Ao usar o método equals() para comparação, o resultado da comparação realmente depende da implementação específica do método equals().
Como todos sabemos, qualquer classe herda da classe Object, então todas as classes têm as características de a classe Object, como String, Integer, etc., eles reescreveram o método equals() em sua própria classe. Neste momento, eles estão comparando valores numéricos. Na implementação padrão da classe Object, a camada inferior da classe equals() método é implementado por meio de.
6.2 Exercício: == e teste igual
Criar pacote: cn.tedu.api
Criar classe: Test.java
package cn.tedu.api;
/**本类用于测试==与equlas的区别*/
public class Test{
public static void main(String[] args) {
Person p1 = new Person("凹凸曼",16);
Person p2 = new Person("凹凸曼",16);
System.out.println(p1 == p2);//false,new了两个对象,p1和p2保存的地址值不同
System.out.println(p1.name == p2.name);//true,name是String类型,保存在常量池中,值是同一个
System.out.println(p1.age == p2.age);//true,age是int基本类型,保存的值都是18
//第一次测试:结果false,使用的是Object默认的逻辑,也是用==来比较的
//第二次测试:结果true,重写equals()后,就会使用子类重写后的功能,也就是说此时比较的不再是地址,而是类型&属性值
System.out.println(p1.equals(p2));
}
}
//1.创建Person类
class Person {
String name;
int age;
public Person() {
System.out.println("我是手动添加的无参构造");
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
//需求:比较两个对象的属性值,如果属性值都一样,就是"同一个对象",要求equals返回true
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
6.3 A diferença entre StringBuilder e StringBuffer
1. Em termos de segurança de thread:
–StringBuffer é fornecido pela versão antiga e é thread-safe. @desde JDK1.0
–StringBuilder é gerado após jdk1.5, thread inseguro. @since 1.5
2. Em termos de eficiência de execução, StringBuilder > StringBuffer > String
3. Incorporação do código-fonte: Em essência, ele está chamando a classe abstrata pai AbstractStringBuilder para funcionar, mas Buffer adiciona a palavra-chave de sincronização ao código, para que o programa pode garantir problemas de segurança do thread.
