1. Cadena Java
Las cadenas se tratan como objetos de tipo cadena en Java. La clase String está en el paquete java.lang, que se importa automáticamente de forma predeterminada.
Una vez creado el objeto String, no se modificará. Cuando modificamos un objeto string, en realidad apuntamos la referencia original al espacio de memoria recién creado. Y la misma cadena constante de Java no asignará dos espacios de memoria, sino que señalará dos referencias al mismo espacio.
public class MyString {
public static void main(String[] args) {
String s1="字符串";
String s2="字符串";
String s3=s1;
System.out.println(s1==s2); // s1、s2字符串内容相同，指向相同的内存空间，输出：true
System.out.println(s1==s3); // 修改之前s1与s3相同，输出：true
s1="修改字符串";
System.out.println(s1==s3); // 修改之后s1指向新的内存空间，与s3不同，输出：false
}
}
Métodos comunes en String:
Si necesita usar cadenas modificadas con frecuencia, puede usar la clase StringBuilder para guardar, puede modificar la cadena a través de agregar, reemplazar y otros métodos, después de que la modificación todavía apunte a la misma dirección de memoria
public class MyString {
public static void main(String[] args) {
StringBuilder s4=new StringBuilder("初始字符串");
StringBuilder s5=s4;
s4.replace(0,10,"修改后的字符串");
System.out.println(s4);
System.out.println(s4==s5); // 修改后仍然指向同一块内存，因此输出：true
}
}
2. Clases de empaque en Java
Los tipos de datos básicos en Java, como int y double, no tienen las características de los objetos. Para tener sus propios métodos como otros objetos, Java proporciona una clase de contenedor para cada tipo de datos básicos, operando el tipo de datos básicos como un objeto. Los métodos básicos de la clase wrapper se utilizan para convertir entre tipos.
La clase de empaquetado de Java puede encajonar / desempaquetar automáticamente, es decir, la conversión de tipo entre el tipo básico y la clase de empaquetado la completa automáticamente el operador =
// 定义int类型变量，值为86
int score1 = 86;
// 使用int创建Integer包装类对象，手动装箱
Integer score2=new Integer(score1);
Integer score2=score1; //自动装箱
// 将Integer包装类转换为double类型
double score3=score2.doubleValue();
// 将Integer包装类转换为float类型
float score4=score2.floatValue();
// 将Integer包装类转换为int类型，手动拆箱
int score5 =score2.intValue();
int score5 = score2 // 自动拆箱
// 将字符串转为int
int score6 = Integer.parseInt("666");Conversión entre tipos básicos y cadenas:
Use la clase Date en el paquete java.util para crear un objeto de tiempo, y use la clase SimpleDateFormat en el paquete java.text para convertir la hora en una cadena en el formato deseado, donde "aaaa-MM-dd HH: mm: ss" es el pre Defina la cadena, aaaa significa año de cuatro dígitos, MM significa dos meses, dd significa día de dos dígitos, HH significa hora (usando un reloj de 24 horas), mm significa minuto, ss significa segundo, por lo que se especifica el formato de conversión objetivo, y finalmente Llame al método format () para convertir la fecha del objeto de tiempo en una cadena en el formato especificado; de lo contrario, el método parse () puede convertir la cadena ordinaria en un objeto Date.
La clase java.util.Calendar facilita el procesamiento del tiempo. Puede obtener un objeto Calendar llamando al método estático getInstance () , que representa la hora actual de forma predeterminada. Puede convertirlo en un objeto Date mediante c.getTime () Más métodos del objeto Calendario son los siguientes
La clase Math se encuentra en el paquete java.lang y contiene métodos para realizar operaciones matemáticas básicas. Todos los métodos de la clase Math son métodos estáticos, por lo que al usar métodos en esta clase, puede usar directamente el nombre de la clase. El nombre del método, como: Math .round ();
3. Recolección de datos en Java
Basado en varios tipos de datos básicos, Java usa clases de colección como contenedores para almacenar objetos con los mismos atributos. Organizar datos a través de clases de recopilación puede realizar la rápida inserción, eliminación y consulta de datos específicos. Y en comparación con la matriz, la longitud de la colección es flexible y variable, y el método de búsqueda no es solo un subíndice. Las clases de colección comunes en Java se dividen en dos interfaces, Collection y Map, donde Collection tiene tres subinterfaces listas enlazadas List, queue Queue y Set. La clase de implementación común de List es la secuencia de matriz ArrayList, y la clase de implementación de Queue es LinkedList. La clase es un conjunto hash. Los datos se almacenan uno por uno en la Colección, y los datos se almacenan en el Mapa de acuerdo con el par clave-valor <clave, valor>.
La interfaz de Colección estipula los métodos de interfaz de clases de implementación específicas como ArrayList y Set. Por ejemplo, todos usan el método add () para agregar elementos, por lo que algunos nombres de métodos son comunes en la implementación de cada clase.
Lista de arreglo
ArrayList es un contenedor similar a una matriz, que almacena objetos en ArrayList para facilitar su organización y administración. Puede insertar un solo objeto en la lista a través del método add (), addAll () puede insertar una sublista compuesta de múltiples objetos en la lista principal, puede especificar la posición de inserción al insertar, puede usar Arrays.asList () para convertir la matriz de objetos en un objeto Luego se inserta la lista. Por ejemplo, inserte el objeto Course en la lista courseList:
public void addCourse(){
Course c1=new Course(1,"数据结构");
Course c2=new Course(2,"操作系统");
Course[] cArr={new Course(3,"组成原理"),new Course(4,"计算机网络")};
courseList.add(c1); // 向数组列表中添加对象
courseList.add(0,c2); // 向指定位置添加对象
courseList.addAll(Arrays.asList(cArr)); // 向列表中添加子列表，前加数字表示插入位置
Course tmp=(Course)courseList.get(0); // 从列表中取出对象
}Puede obtener la longitud de la lista a través del método size (), obtener el objeto en la posición especificada a través del método get () y luego atravesar cada objeto a través del bucle for, o puede usar el método for each para recorrer cada elemento. También puede acceder a cada objeto a través de un iterador. Vale la pena señalar que cada objeto se almacena como un objeto Object en la lista, por lo que después de sacarlo, debe convertirse al tipo de objeto original por tipo forzado, como (Course) se convierte en un objeto de la clase Course
public void showCourse(){
int listLength=courseList.size(); // 获取列表长度
for (int i=0;i<listLength;i++) {
Course c=(Course)courseList.get(i); // 获取列表第i个元素
System.out.println(c.name);
}
}
public void iteratorCourse(){
Iterator it=courseList.iterator(); // 获取迭代器
while (it.hasNext()){ // 如果仍有下一个元素
Course c=(Course)it.next(); // 取出下一个元素
System.out.println(c.name);
}
}Modifique el elemento en la posición especificada de la lista a través del método set (). Elimine la ubicación especificada o el objeto especificado a través del método remove (). Use removeAll () para eliminar todos los elementos en la lista secundaria contenida en la lista primaria
public void modifyCourse(){
courseList.set(2,new Course(5,"离散数学")); // 修改2位置上的对象
}
public void removeCourse(){
courseList.remove(3); // 删除3位置上的对象
Course c1= (Course) courseList.get(1);
Course c2=(Course) courseList.get(2);
courseList.remove(c1); // 删除指定对象
Course[] cArr={c1,c2};
courseList.removeAll(Arrays.asList(cArr)); // 删除courseList中所包含的cArr的元素
}Utilice los métodos contiene () y contiene todos () para determinar si la Lista contiene uno o varios objetos. Su principio de implementación es atravesar cada objeto en la Lista y llamar a su método equals () para comparar con el objeto de destino. Si existe, devuelva verdadero, de lo contrario Devuelve falso. Por lo tanto, podemos anular el método equals () de la clase del curso y luego llamar al método contiene () para determinar si la lista contiene el objeto del curso especificado. Del mismo modo, el método indexOf () puede encontrar la primera aparición del elemento en la Lista llamando a equals ().
// 重写Course类的equals()方法
public boolean equals(Object o) {
if (this == o) return true; // 如果两个对象的地址相同，肯定相同
if (!(o instanceof Course)) return false;
Course course = (Course) o;
return id == course.id && // 判断两个Course对象的id和name相同
name.equals(course.name);
}
// 在CourseList中调用contains()判读是否包含某个对象
public void containCourse(){
Course nc=new Course(5,"数据结构");
if(courseList.contains(nc)) { // 判断List中是否包含Course对象nc
int index = courseList.indexOf(nc); // 获取元素在List中的位置
System.out.println("列表中包含该课程，位置：" + index);
}
}Como se mencionó anteriormente, todos los objetos almacenados en la colección son referencias a objetos. Cada vez que se almacena la colección, se ignora el tipo específico del objeto. A veces, se almacenan otros tipos de objetos y se producen errores en el tiempo de ejecución, y cada vez que se retiran La conversión de tipo se restaura de nuevo. Puede usar genéricos para especificar que una colección solo puede almacenar objetos de un tipo específico o sus subtipos, de modo que la verificación de tipo se realizará durante la compilación, y los objetos de un tipo específico se pueden devolver directamente cuando se recuperan. Tenga en cuenta que los genéricos no se pueden usar para los tipos de datos básicos. Por ejemplo, List <int> informará un error y se debe usar su clase de contenedor List <Integer>.
// 创建元素类型为Course的列表
public List<Course> courseList=new ArrayList<Course>();
public void addCourse(){
Course c=new Course(6,"数据结构");
courseList.add(c);
// courseList.add("字符串"); // 尝试向列表中添加非Course类型的对象，报错
Course c2=courseList.get(0); // 可以直接取出为Course类型对象
System.out.println(c2.name);
}La clasificación de los objetos List se puede lograr mediante el método Collections.sort () de la clase de herramienta de recopilación . El principio de su implementación es llamar al método compareTo () de cada elemento para comparar y ordenar los objetos. Por lo tanto, cada objeto debe ser de un tipo comparable, es decir, un objeto que debe implementar la interfaz Comparable. Como se muestra a continuación, primero defina la clase comparable Estudiante, y luego defina la lista de estudiantes studentLis. Después de agregar el objeto de estudiante, llame al método Collections.sort () para realizar la lista Ordenar
public class Student implements Comparable<Student> { // 定义Student类实现Comparable接口
public String name;
public int id;
public Student(int id, String name) {
this.name = name;
this.id = id;
}
@Override
public int compareTo(Student o) { // 实现接口的方法，根据id大小对学生进行比较
if (this.id>o.id){ // 如果大于o返回1
return 1;
}else if (this.id<o.id){ // 小于返回-1
return -1;
}else { // 等于返回0
return 0;
}
}
}
public class ListSort {
public List<Student> studentList=new ArrayList<Student>(); // 学生列表
public void sortStudent(){
Student s1=new Student(1011,"小明");
Student s2=new Student(1005,"小赵");
Student s3=new Student(1021,"小钱");
Student[] sArr={s1,s2,s3};
studentList.addAll(Arrays.asList(sArr));
Collections.sort(studentList); // 调用方法对学生列表进行排序
for (Student s:studentList) {
System.out.println(s.id+":"+s.name);
}
}
}También puede pasar un comparador de objetos de comparación personalizado al llamar al método sort () para lograr la comparación de los dos objetos, entonces la clase Student no necesita implementar la interfaz Comparable
// 自定义比较器类来实现两个Student对象的比较
public class StudentComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
if (o1.id>o2.id){ // 如果大于o返回1
return 1;
}else if (o1.id<o2.id){ // 小于返回-1
return -1;
}else { // 等于返回0
return 0;
}
}
}
// 调用修改如下：
Collections.sort(studentList,new StudentComparator());
HashSet
Hash set es una clase de implementación de Set. A diferencia de la lista, los elementos en set están desordenados y no pueden repetirse.
Al igual que List, add, delete y otras operaciones se implementan en Set mediante add (), remove () y otros métodos. Debido a que Set no está ordenado, no existe un método set (), get () para insertar / obtener elementos en la posición especificada e iterar a través de los elementos para cada iterador, y el orden de resultados de cada recorrido es incierto.
Tenga en cuenta que el método contiene () en el HashSet primero llamará al método hashCode () del objeto para comparar el código hash, y luego llamará al método equals (). Si ambos son verdaderos, los dos objetos se considerarán iguales.
Por ejemplo, a través de HashSet para almacenar el curso seleccionado por el alumno
public class Student {
public String name;
public int id;
public Set<Course> courses; // 用set保存学生所选课程
public Student(int id, String name) {
this.name = name;
this.id = id;
this.courses=new HashSet<Course>(); //创建Hash集
}
public static void main(String[] args){
Course c=new Course(1,"数据结构");
Student s=new Student(101,"小明");
s.courses.add(c); // 向集中添加对象
for (Course course:s.courses) { // 遍历集
System.out.println(course.name);
}
}
}HashMap
Map almacena datos en forma de pares clave-valor uno a uno <clave, valor>. La clave se puede utilizar para encontrar rápidamente el valor a través de la relación de asignación, y el valor clave no se puede repetir. El mapa también admite el mapa genérico <K, V>. Agregue pares clave-valor al Mapa por put (clave, valor), elimine (clave) elimine la clave. Las claves, los valores y los pares clave-valor del Mapa se pueden obtener a través de los métodos keySet (), values () y entrySet () respectivamente. Los pares clave-valor devueltos Entry todavía pueden definir tipos genéricos. Modificar el par clave-valor del Mapa también usa el método put (), el nuevo par clave-valor sobrescribirá el valor original. El método contiene clave (clave) puede devolver si el mapa contiene un valor clave, contiene valor (valor) devuelve si el mapa contiene un cierto valor y si existe llamando al método equals () del objeto.
// 创建存储学生类的哈希Map
public Map<Integer,String> studentMap=new HashMap<Integer, String>();
public void addStudent(){
Scanner input=new Scanner(System.in);
System.out.print("请输入学生ID：");
int studentID=input.nextInt();
String s=studentMap.get(studentID); // 根据key值获取对应的value
if (s!=null){ // 如果s不为空说明该key已经存在
System.out.println("该学生ID已存在！");
}else {
System.out.print("请输入姓名：");
String name=input.next();
studentMap.put(studentID,name); // 将<ID,name>键值对添加到Map中
}
}
public void showStudent(){ //通过foreach遍历HashMap
// 获取Map的键值对Entry并对其泛型进行定义
Set<Map.Entry<Integer,String>> entrySet=studentMap.entrySet();
for(Map.Entry<Integer,String> entry:entrySet){
int key= entry.getKey(); // 从Entry中获取key
String name=entry.getValue(); // 从Entry中获取value
System.out.println(key+":"+name);
}
}
public void showStudent2(){ //通过迭代器遍历HashMap
Iterator iter = studentMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
Int key= entry.getKey();
String name = entry.getValue();
System.out.println(key+":"+name);
}
}
