import java.util.Arrays;
public class TestDemo {
// 数组的有序性
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
boolean flg = isUp(array);
System.out.println(flg);
}
public static boolean isUp(int[] array) {
for (int i = 0; i < array.length-1; i++) {
if (array[i] > array[i+1]) {
return false;
}
}
return true;
}
// 数组排序
// 冒泡排序
public static void main(String[] args) {
int[] array = {1,3,4,1,5,6};
bubbleSort(array);
System.out.println(Arrays.toString(array));
Arrays.sort(array);
System.out.println(Arrays.toString(array));
}
public static void bubbleSort(int[] array) {
for (int i = 0; i < array.length-1; i++) {
boolean flg = false;
for (int j = 0; j < array.length-1-i; j++) {
if (array[j] > array[j+1]) {
int tmp = array[j];
array[j] = array[j+1];
array[j+1] = tmp;
flg = true;
}
}
if (flg == false) {
return ;
}
}
}
// 数组填充
public static void main(String[] args) {
int[] array = new int[10];
Arrays.fill(array,99);
System.out.println(Arrays.toString(array));
Arrays.fill(array,2,6,1999); // [2,6)
System.out.println(Arrays.toString(array));
}
// 数组逆序
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
reverse(array);
System.out.println(Arrays.toString(array));
}
public static void reverse(int[] array) {
int i = 0;
int j = array.length-1;
while (i < j) {
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
i++;
j--;
}
}
// 偶数放到前面
public static void main(String[] args) {
int[] array = {1,2,3,4,5,6};
func(array);
System.out.println(Arrays.toString(array));
}
public static void func(int[] array) {
int left = 0;
int right = array.length-1;
while (left < right) {
while (left < right && array[left] % 2 == 0) {
left++;
}
while (left < right && array[right] % 2 == 1) {
right--;
}
int tmp = array[left];
array[left] = array[right];
array[right] = tmp;
}
}
// 数组拷贝
// 第一种
public static void main(String[] args) {
int[] array = {1,2,3,4,5,6};
System.out.println(Arrays.toString(arrayCopy(array)));
}
public static int[] arrayCopy(int[] array) {
int[] copy = new int[array.length];
for (int i = 0; i < array.length; i++) {
copy[i] = array[i];
}
return copy;
}
// 第二种
public static void main(String[] args) {
int[] array = {1,2,3,4,5,6};
int[] ret = Arrays.copyOf(array,array.length*2); // 用的最多
System.out.println(Arrays.toString(ret));
int[] ret2 = Arrays.copyOfRange(array,1,3); // [1,3)
System.out.println(Arrays.toString(ret2));
int[] copy = new int[array.length];
System.arraycopy(array,0,copy,0,array.length);
System.out.println(Arrays.toString(copy));
int[] copy1 = array.clone();
System.out.println(Arrays.toString(copy1));
}
// 浅拷贝 copy和array指向同一个对象
// 四种都是浅拷贝
// 二维数组
public static void main(String[] args) {
int[][] array = {{1,2,3},{4,5,6}};
int[][] array2 = new int[][]{{1,2,3},{4,5,6}};
int[][] array3 = new int[2][3];
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]+" ");
}
System.out.println();
}
System.out.println(array.length); // 2
System.out.println(array[0].length); // 3
for (int[] ret : array) {
for (int x : ret) {
System.out.print(x+" ");
}
System.out.println();
}
System.out.println(Arrays.deepToString(array));
}
public static void main(String[] args) {
int[][] array = {{1,2},{4,5,6}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]+" ");
}
System.out.println();
}
int[][] array2 = new int[2][];
array2[0] = new int[3];
array2[1] = new int[2];
// 不规则的二维数组
}
public static void main(String[] args) {
Person person = null; // 没有指向一个对象
Person person1 = new Person(); // 实例化对象
System.out.println(person1.name); // null
person1.name = "朱超";
System.out.println(person1.name); // 朱超
// 普通成员变量的访问需要通过对象的引用来访问
person1.sleep();
}
}
// 类和对象
// 1.什么是类
// 2.什么是对象
// 面向对象和面向过程
// 面向对象：找对象 创建对象 使用对象
// 类产生对象：实例化（new）
class Person {
// 类名 大驼峰
// 字段（属性）（成员变量）
// 方法（行为）
// 成员变量（字段）：定义在类的内部 方法的外部
// 普通成员变量 静态成员变量
public String name;
public int age;
// 方法
// 普通方法 静态方法
public void eat() {
System.out.println(name+"正在吃饭");
}
public void sleep() {
System.out.println(name+"正在睡觉");
}
}
