两种数据类型：根本数据类型和引证数据类型的差异
1.存储办法不同:
根本数据类型他是存储在JVM运行时数据区栈空间上，存储在栈上的数据能够快速地被拜访和处理。
引证数据类型呢因为引证目标的巨细不固定，所以引证数据类型的引证地址是存储在栈空间，详细的为目标分配的空间巨细是在堆空间进行的。因此，引证数据类型的变量在声明时仅仅分配了存储空间，需求经过new关键字来创立目标并将目标的引证赋值给变量。
2.巨细不同:
进本数据类型是有限的，它能够在编译时就能确认数据类型的巨细，而引证类型他是依据目标巨细进行分配空间所以空间巨细是不固定的。
3.默认值不同：
根本数据类型都有各自的默认值例如：int 默认值是0 ，引证类型的默认值是null。
4.传递值办法不同：
根本数据类型传值是值的副本进行传递，引证类型传递的是引证地址的副本。
5.操作办法不同 ：
根本数据类型是对值进行操作，引证数据类型是对目标进行操作。
引证数据类型包括？
类、接口、枚举
在Java中，除了根本数据类型（如int、double等），其他所有类型都是引证类型，包括自定义的类、接口和枚举等。咱们创立一个类时，实践上是创立了一个引证类型，咱们能够经过该类创立目标，并将目标的引证赋值给变量
数组类型
数组的作用是存储多个引证类型的目标，能够经过数组的下标进行拜访和操作目标。
数组能够用于完成数据结构中的列表、行列、栈等数据结构也能够用于存储多个目标的调集，便利进行遍历、挑选、排序等操作。在实践开发中，数组常用于存储用户信息、商品信息、订单信息等数据。
事例完成对列数据结构（先进先出）：
java简单罗列那些场景会用到对列：
- 线程池：线程池中的任务能够被放入行列中，等候线程池中的线程来处理。
- 音讯行列：音讯行列能够用于在不同的应用程序之间传递音讯。
- 音讯行列：音讯行列能够用于在不同的应用程序之间传递音讯。
public class Queue {
private int[] queueArray; // 行列数组
private int front; // 队首指针
private int rear; // 队尾指针
private int maxSize; // 行列最大容量
// 结构函数，初始化行列
public Queue(int size) {
maxSize = size;
queueArray = new int[maxSize];
front = 0;
rear = -1;
}
// 入队操作
public void enqueue(int item) {
if (rear == maxSize - 1) { // 行列已满
System.out.println("Queue is full!");
return;
}
queueArray[++rear] = item; // 队尾指针加1，将元素刺进队尾
}
// 出队操作
public int dequeue() {
if (isEmpty()) { // 行列为空
System.out.println("Queue is empty!");
return -1;
}
int item = queueArray[front++]; // 取出队首元素，并将队首指针加1
return item;
}
// 判别行列是否为空
public boolean isEmpty() {
return (front == rear + 1);
}
// 获取行列长度
public int size() {
return rear - front + 1;
}
// 获取队首元素
public int peek() {
if (isEmpty()) { // 行列为空
System.out.println("Queue is empty!");
return -1;
}
return queueArray[front];
}
}
以上代码完成了一个根本的行列，包括入队、出队、判别行列是否为空、获取行列长度、获取队首元素等操作
事例完成栈数据结构（先进后出）：
// 结构函数，初始化栈
public Stack(int size) {
maxSize = size;
stackArray = new int[maxSize];
top = -1;
}
// 入栈操作
public void push(int item) {
if (top == maxSize - 1) { // 栈已满
System.out.println("Stack is full!");
return;
}
stackArray[++top] = item; // 栈顶指针加1，将元素刺进栈顶
}
// 出栈操作
public int pop() {
if (isEmpty()) { // 栈为空
System.out.println("Stack is empty!");
return -1;
}
int item = stackArray[top--]; // 取出栈顶元素，并将栈顶指针减1
return item;
}
// 判别栈是否为空
public boolean isEmpty() {
return (top == -1);
}
// 获取栈长度
public int size() {
return top + 1;
}
// 获取栈顶元素
public int peek() {
if (isEmpty()) { // 栈为空
System.out.println("Stack is empty!");
return -1;
}
return stackArray[top];
}
public static void main(String[] args) {
Stack stack = new Stack(5);
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
stack.push(5);
System.out.println("栈长度：" + stack.size());
System.out.println("栈顶元素：" + stack.peek());
while (!stack.isEmpty()) {
System.out.println(stack.pop());
}
}
以上代码完成了一个根本的栈，包括了栈的结构函数、入栈操作、出栈操作、判别栈是否为空、获取栈长度和获取栈顶元素等办法
对列和栈之间的不同之处：操作办法不同。栈是一种后进先出（Last In First Out，LIFO）的数据结构，只能在栈顶进行刺进和删除操作；而行列是一种先进先出（First In First Out，FIFO）的数据结构，只能在行列的一端进行刺进操作，在另一端进行删除操作
假设咱们要存储多个学生目标，每个学生目标包括姓名、年龄、性别等特点，能够使用数组来存储这些学生目标。（数组事例）
public class Student {
private String name;
private int age;
private String gender;
public Student(String name, int age, String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String getGender() {
return gender;
}
}
public class StudentCollection {
private Student[] students;
private int size;
public StudentCollection(int capacity) {
students = new Student[capacity];
size = 0;
}
public void add(Student student) {
if (size == students.length) {
// 数组已满，需求扩容
Student[] newStudents = new Student[students.length * 2];
System.arraycopy(students, 0, newStudents, 0, students.length);
students = newStudents;
}
students[size++] = student;
}
public int size() {
return size;
}
public Student get(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index out of range: " + index);
}
return students[index];
}
public void remove(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index out of range: " + index);
}
System.arraycopy(students, index + 1, students, index, size - index - 1);
size--;
}
public void sortByName() {
Arrays.sort(students, 0, size, Comparator.comparing(Student::getName));
}
public void sortByAge() {
Arrays.sort(students, 0, size, Comparator.comparingInt(Student::getAge));
}
public Student[] filterByGender(String gender) {
Student[] result = new Student[size];
int count = 0;
for (int i = 0; i < size; i++) {
if (students[i].getGender().equals(gender)) {
result[count++] = students[i];
}
}
return Arrays.copyOf(result, count);
}
}
Student类表示一个学生目标，StudentCollection类表示多个学生目标的调集。StudentCollection类使用一个数组来存储学生目标，供给了增加、获取、删除、排序、挑选等操作。
字符串类型：String类
String类的一些常用办法，例如拼接字符串、转化巨细写、去除空格、比较字符串等。这些办法都是String类供给的，能够便利地操作字符串。
以下是一些常用的办法：
- length()：回来字符串的长度。
- charAt(int index)：回来指定索引处的字符。
- substring(int beginIndex, int endIndex)：回来从beginIndex到endIndex-1的子字符串。
- indexOf(String str)：回来str在字符串中第一次出现的索引。
- lastIndexOf(String str)：回来str在字符串中最后一次出现的索引。
- equals(Object obj)：比较字符串是否相等。
- toLowerCase()：将字符串转化为小写。
- toUpperCase()：将字符串转化为大写。
- trim()：去除字符串两头的空格。
- replace(char oldChar, char newChar)：将字符串中的oldChar替换为newChar。
- split(String regex)：依据正则表达式将字符串分割成字符串数组。
- startsWith(String prefix)：判别字符串是否以prefix开头。
- endsWith(String suffix)：判别字符串是否以suffix结尾。
- contains(CharSequence s)：判别字符串是否包括s。
- isEmpty()：判别字符串是否为空。
事例介绍
public class StringExample {
public static void main(String[] args) {
String str1 = "Hello";
String str2 = "World";
String str3 = str1 + " " + str2; // 拼接字符串
System.out.println(str3); // 输出 "Hello World"
String str4 = "hello world";
System.out.println(str4.toUpperCase()); // 输出 "HELLO WORLD"
System.out.println(str4.toLowerCase()); // 输出 "hello world"
String str5 = " hello world ";
System.out.println(str5.trim()); // 输出 "hello world"
String str6 = "hello";
String str7 = "world";
System.out.println(str6.equals(str7)); // 输出 false
System.out.println(str6.compareTo(str7)); // 输出 -15
}
}
以下是一些常用的办法：
- equals(Object obj)：判别两个目标是否相等。
- hashCode()：回来目标的哈希码。
- toString()：回来目标的字符串表示。
- getClass()：回来目标的类。
- notify()：唤醒在此目标监视器上等候的单个线程。
- notifyAll()：唤醒在此目标监视器上等候的所有线程。
- wait()：使当时线程等候，直到另一个线程调用此目标的 notify() 或 notifyAll() 办法。
- wait(long timeout)：使当时线程等候，直到另一个线程调用此目标的 notify() 或 notifyAll() 办法，或许指定的时刻现已曩昔。
- wait(long timeout, int nanos)：使当时线程等候，直到另一个线程调用此目标的 notify() 或 notifyAll() 办法，或许指定的时刻现已曩昔。
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
// 测验
Person p1 = new Person("Tom", 20);
System.out.println(p1.getClass()); // class Person
public class Person implements Cloneable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
// 测验
Person p1 = new Person("Tom", 20);
Person p2 = (Person) p1.clone();
System.out.println(p1 == p2); // false
还有些常用的类罗列到下面就不进行举例了
-
- Date和Calendar类：用于处理日期和时刻，供给了许多日期和时刻操作办法。
-
- Math类：用于数学核算，供给了许多数学核算办法。
-
- Random类：用于生成随机数，供给了许多随机数生成办法。
以上便是今日内容：关于引证数据类型及简单介绍。咱们等待和我们下次相遇：内容如有错误的当地，希望我们纠正。
