两种数据类型：基本数据类型和引用数据类型的区别
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类：用于生成随机数，提供了很多随机数生成方法。
以上就是今日内容：关于引用数据类型及简单介绍。我们期待和大家下次相遇：内容如有错误的地方，希望大家指正。
