Kagayaの小站
返回文章列表
后端

java学习

Java的学习记录

2026.10.0825 分钟阅读文 / Kagaya
文章封面

HelloWorld

public class Helloworld{
    public static void main (Static[] args){
        System.out.print("Hello,world!");
    }
}

编译: javac Helloworld.java 运行: java Helloworld.java

数据类型:

1.基本数据类型有哪些？它们的长度是否会根据不同类型而变化？

Java的基本数据类型包括：byte、short、int、long、float、double、char、boolean。 这些基本数据类型在Java中各自占用的字节数是固定的，不会根据不同数据而变化。比如，int类型一般占用4个字节（32位），double类型一般占用8个字节（64位）。

2.基本数据类型的位数大致是多少？比如整型的取值范围是多大？

byte（8位）、short（16位）、int（32位）、long（64位）、float（32位）、double（64位）、char（16位，Unicode字符）、boolean（未定义）。

整型的取值范围：


byte：8位，范围为 -128 到 127

short：16位，范围为 -32768 到 32767

int：32位，范围为 -2147483648 到 2147483647

long：64位，范围为 -9223372036854775808 到 9223372036854775807

3.进制开头

二进制十进制八进制十六进制
进制开头0b00x

4.高精度浮点类

    float f == 0.1f; //0.1
    double d = 1.0/10; //0.1
  
    System.out.println(f==d);
    //输出的应该是false,浮点数 有限 离散  有舍入误差 大约数
    System.out.println(f);//0.1
    System.out.println(d);//0.1
  
    float d1 = 2313131313131313131313f;
    float d2 = d1 + 1;
  
    System.out.println(d1 == d2);
    //输出的应该是true,精度不够

存储高精度数字时应该用BigDecimal类

5.字符扩展

    char c1 = 'a';
    char c2 = '中';
  
     System.out.println(c1);//a
     System.out.println((int)c1);//强制转换//97
   
     System.out.println(c2);//中
     System.out.println((int)c2);//强制转换//20013

所有的字符本质是数字

编码: Unicode编码 2字节 65536字长(U0000~UFFFF)

6.转义字符

转义序列含义记忆技巧 / 核心使用场景
\n换行符（LF）打印日志、字符串中换行（Unix/Linux/macOS 标准）
\r\nWindows 换行符生成 Windows 文本文件时使用（回车+换行）
\t水平制表符（Tab）对齐文本、缩进输出内容
\"双引号在字符串中表示双引号本身，如 "他说："你好"
\'单引号在 char 类型中表示单引号，如 char c = ''';（注：在 String 中直接写 ' 即可，无需转义）
\\反斜杠最常用：Windows 文件路径（"C:\Users\test.txt"）和正则表达式（如匹配数字写 "\d"）

7.布尔值

    boolean flag = true;
    if (flag == true){};
    if(flag) {} //代码精简

类型转换

类型由低 -> 高

byte,short,char -> int -> long -> float -> double

高类型转低类型需要强制转换

布尔值不能转换

在把高容量准换到低容量时强制转换

转换时可能存在内存溢出或者精度问题

    System.out.println((int)23.7);  //输出23,失去精度
    System.out.println((int)-45.89f); //输出45
  
    char c = 'a';
    int d = c + 1;
    System.out.println(d); //输出98
    System.out.println((char)d) //输出b

// jdk7新特性:数字可以用下划线分割
    int money = 10_0000_0000;
    int years = 20;
    int total = money*years;//-1474836480 计算时溢出了
    int total2 = money*years;//默认数据类型是int,
  
    long total3 = money*((long)years); //先把一个数换为long
    System.out.println(total3);//输出

变量、常量、作用域

1. 变量就是可以变化的量

    type varName [=value] [{,varName[value]}] ;
    //数据类型 变量名 = 值 ;   用逗号隔开来声明不同的值
  
    int a = 1;
    String name = "";
    char x = X;

2.常量

常量是特殊的变量,初始化后值不能再被改变

final 常量名 = 值 ;
final double PI = 3.14;

final 代表常量

示例:

public class Demo {
    //修饰符不存在先后顺序
    static final double PI = 3.14;
  
    public static void main(String[]] args){
        System.out.println(PI);
    }
}

3.作用域

  • 类变量
  • 实例变量
  • 局部变量
public class Demo {
    //类变量 static
    static double salary = 2500;
  
    //属性:变量
  
    //示例变量,从属于对象;如果不进行初始化,这个类型的默认值
    //布尔值默认是 false
    //除了基本类型,其余默认值都是null
        Syring name;
        int age;
  
  
    ///main方法
    public static void main(String[] args) {
        //局部变量是在方法内的;必须声明和初始化值
        int i = 10;
        System.out.println(i);
  
        //变量类型 变量名字 = new Demo();
        Demo demo = new Demo() ;
        Systm.out.println(demo.age);
        Systm.out.println(demo.name);
  
        //类变量 static
        System.out.println(salary);//输出2500
    }
  
    //其他方法   
    public void add() {
  
    }
}

4.变量的命名规范

  • 所有变量、方法、类名:见名知意
  • 类成员变量首字母小写和驼峰原则:monthSalay 除了第一个单词以外,后面的单词首字母大写 lastName
  • 局部变量: 首字母小写和驼峰原则
  • 常量:大写字母和下划线: MAX_VALUE
  • 类名:首字母大写和驼峰原则:Man,GoodMan
  • 方法名:首字母小写和驼峰原则:run(),runRun()

运算符

第一类：算术运算符（用于数值计算）。

运算符含义示例
+加 / 字符串拼接a + b
-减a - b
*乘a * b
/除（整数相除取整）10 / 3 = 3
%取模（取余）10 % 3 = 1

第二类：关系运算符（结果为 boolean）。

运算符含义示例
==等于a == b
!=不等于a != b
>=大于 / 大于等于
<=小于 / 小于等于

第三类：逻辑运算符（操作 boolean 值）。

运算符含义注意
&&短路与（一假即假）左边 false 则不执行右边
!非（取反）单目运算符
&非短路与（按位与也可用于布尔）两边都执行
非短路或（按位或也可用于布尔）
^异或（相同 false，不同 true）较少用于逻辑，多用于位运算

第四类：赋值运算符。

运算符等价于示例
=直接赋值a = 10
+=加后赋值a += b → a = a + b
-=减后赋值a -= b → a = a - b
*=乘后赋值a *= b → a = a * b
/=除后赋值a /= b → a = a / b
%=取余后赋值a %= b → a = a % b
&= ,= ,^=按位与后赋值
=按位或后赋值
^=按位异或后赋值a ^= b
<<=左移后赋值a <<= 2 → a = a << 2
>>=右移后赋值a >>= 2
>>>=无符号右移后赋值a >>>= 2

第五类：位运算符（操作二进制位）。

运算符含义示例
&按位与5 & 3 → 1（0101 & 0011 = 0001）
|按位或5
^按位异或5 ^ 3 → 6（0101 ^ 0011 = 0110）
~按位取反（单目）~5 → -6（包括符号位取反）
<<左移（低位补0）5 << 1 → 10（相当于 ×2）
>>右移（高位补符号位）-5 >> 1 → -3（正负号保留）
>>>无符号右移（高位补0）-5 >>> 1 → 2147483645（只对正数等同 >>）

第六类：一元运算符（作用于单个操作数）。

运算符含义注意
++自增（前/后）i++（先用后加），++i（先加后用）
--自减（前/后）i--（先用后减）、--i（先减后用）
+正号+5（通常省略不写）
-负号-5（取负数)
!逻辑非(取反)!true → false（已列于逻辑运算符）

第七类：三元运算符（条件运算符）。

运算符含义示例
? :条件 ? 真值 : 假值int max = a > b ? a : b;（返回 a 和 b 中的较大值)

第八类：其他/特殊运算符。

运算符含义示例
instanceof判断对象是否为某类型实例obj instanceof String（判断对象是否为指定类型）
->Lambda 表达式箭头（Java 8+）list.forEach(item -> System.out.println(item));
::方法引用符（Java 8+）System.out::println
.成员访问对象.方法() 或 类.静态变量
[]数组下标arr[0]
()方法调用 / 优先级括号method()；(a + b) * c
new对象创建new String("hello")（严格来说是关键字，但常被归为运算符）
    int a = 10;
    int b = 20;
  
    a += b;
    a -= b;
  
    System.out.println(a);
    System.out.println(""+a+b);//输出1020
    System.out.println(a+b+"");//输出30

三元运算符

    //x ? y : z
    //如果x == true ,则结果为y,否则结果为z

    int score = 80;
    String type = score < 60 ? "不及格" : "及格";
  
    System.out.println(type);

另外Math工具类能进行很多的数学运算

短路运算

    int c = 5;
    boolean d = (c<4)&&(c++<4); //在&&前已经被判断c<4为0,后面短路运算 c++没有被执行
    System.out.plantln(d); //输出flase
    System.out.println(c); //输出 5

包机制

包必须在代码最上面

一般用公司的域名倒置作为包名

例如: 公司域名 www.baidu.com 包名 : com.baidu.www BaoJiZhi

导包

*是通配符,可以导入这个包下所有的类

    //*是通配符,可以导入这个包下所有的类
    import com.baidu.*;

JavaDos 文档注释

Javadoc命令是用来生成自己的API文档的

  • @author 作者名
  • @version 版本号
  • @since 指名需要最早使用的jdk版本
  • @param 参数名
  • @return 返回值情况
  • @throws 异常抛出情况
    /*
    * @outthor Kagaya
    * @version 1.0
    * @sincee 1.8
    */
    public class Doc{
  
        String name;
  
        /**
        *@param name
        *@return
        *@throws Exception
        */
        public Syring test(String name) throws Exception{
            return name;
        }
  
    }

终端命令

javadoc -encoding UTF-8 -charset UTF-8 Doc.java

-encoding UTF-8 :编码为UTF-8 -charset UTF-8 :字符集为UTF-8 Doc.java :文件名

Java流程控制

Scanner :用键盘输入

  1. 通过 Scanner类的 next()与nextLine()方法获取输入的字符串
  2. 通过Scanner类的next()与nextLine()方法获取输入的字符串,在读取前我们一般需要使用hasNext()与hasNextLinee()判断是否还有输入的数据.

使用next方式接收:

    //创建一个扫描器对象,用于接收键盘数据

    Scanner sc = new Scanner(System.in);

    System.out.println("使用next方式接收:");

    //判断用户有没有输入字符串
    if (scanner.hasNext()){
    String str = sc.next();
    System.out.println("输出的内容为:"+str);
    }
  
    //凡是属于IO流的类不关闭就会一直占用资源
    sc.close();

使用nextLine方式接收:

    //创建一个扫描器对象,用于接收键盘数据
    Scanner sc = new Scanner(System.in);

    System.out.println("使用nextLine方式接收:");

    //判断用户有没有输入字符串
    if (scanner.hasNextLine()){
    String str = sc.nextLine();
    System.out.println("输出的内容为:"+str);
    }
  
    //凡是属于IO流的类不关闭就会一直占用资源
    sc.close();

整数:

    Scanner sc = new Scanner(System.in);

    int i = 0
    float f = 0.0f;
  
  
    System.out.println("请输入整数");
    //如果输入的为整数
    if(sc.hasNextInt()){
        i = sc.nextInt();
        System.out.println("整数数据:"+i);
    }else{
        System.out.println("输入的不是整数数据");
    }

小数:

    Scanner sc = new Scanner(System.in);

    int i = 0
    float f = 0.0f;
  
  
    System.out.println("请输入小数");
    //如果输入的为整数
    if(sc.hasNextFloat()){
        i = sc.nextFloat();
        System.out.println("小数数据数据:"+i);
    }else{
        System.out.println("输入的不是小数数据");
    }

代码执行结构

顺序结构 除非特别指明,否则代码执行都是顺序结构

选择结构

  • if单选择结构
  • if双选择结构
  • if多选择结构
  • 嵌套的if结构
  • switch多选择结构

if - else结构

if 单选择结构:

    Scanner sc = new Scanner(System.in);
    System.out.println("请输入成绩");
    double score = sc.nexDouble();
    if(score > 60 || score == 60){
        System.out.println("及格");
    }else {
        System.out.println("不及格");
    }

if多选择结构:

    Scanner sc = new Scanner(System.in);
    System.out.println("请输入成绩");
    double score = sc.nexDouble();
    if(score > 60 || score == 60 ){
        System.out.println("及格");
    }else if(score < 60){
        System.out.println("不及格");
    }
  • if () 里面是通过布尔值判断的
  • if 语句可以有若干个 else if 语句,他们必须在else语句之前
  • 一旦其中一个else if语句检测为true,其他的else if以及else语句都将跳过执行

switch多选择结构

switch语句中的变量类型可以是:

  • byte short int char
  • 从Java SE 7开始支持了String类型
  • case标签必须为字符串常量或字面量
    public class Demo {
        public static void main(String[] args){
            char grade = 'A';
      
            switch (grade){
                case'A'
                    System.out.print("优秀");
                    break; //返回
                case'B':
                    System.out.print("良好");
                    break;
                case'C':
                    System.out.print("及格");
                    break;
                case'D':
                    System.out.print("挂科");
                    break;
                default:
                    System.out.println("未知等级");
                    break;
            }
      
        }
    }

循环结构

while循环

while是最基本的循环,结构为:

    while(布尔表达式){
        //循环表达式
    }

输出1~100:

    int i = 0;
    while (i<100){
        i++;
        System.out.println(i);
    }

1+2+3+...+100:

    int i = 0;
    int sum = 0;
    while(i<=100){
        sum += i;
        i++;
    }
    System.out.println(sum);

do - while循环

while是先判断后执行,do while是先执行后判断 结构为:

    do{
        //代码语句
    }while(布尔表达式);

1+2+3+...+100:

    int i = 0;
    int sum = 0;
  
    do{
        sum += i;
        i++;
    }while(i <= 100);
  
    System.out.println(sum);

for循环

语法格式如下:

    for(初始化;布尔表达式;更新){
        //代码语句
    }

输出1到100:

    for(int i=1;i<=100;i++){
        System.out.println(i);
    }
  
    System.out,print(循环结束);

分别计算0到100之间的奇数与偶数的和:

    int oddSum = 0;
    int evenSum = 0;
  
    for(int i = 0 ;i < 100;i++){
        if(i % 2 != 0){
            oddSum += i;
        }else {
            evenSum +=i;
        }
    }
  
    System.out.println("奇数和:"+oddSum);
    System.out.println("偶数和:"+evenSum);

练习:用for循环输出1~1000之间能被5整除的数,并且每行输出3个

    //用for循环输出1~1000之间能被5整除的数,并且每行输出3个
        int num = 0;
        for (int i = 0; i < 1000; i++) {
            if(i%5 == 0){
                System.out.print(i+"\t");
                num++;
                if(num %3 == 0){
                    System.out.print('\n');
                }
            }
        }

输出九九乘法表:

    for(int n=1;n<=9;n++){
            for(int m=1;m<=n;m++){
                System.out.print(m+"*"+n+"="+(m*n)+"\t");
                }
            System.out.println();  
        }

打印三角形:

    //打印三角形 5行
        for (int i = 0; i <= 5; i++) {
            for(int j = 5;j >= i;j--) {
                System.out.print(" ");
            }
            for (int j = 1;j <= i;j++){
                System.out.print("*");
            }
            for(int j=1;j < i;j++){
                System.out.print("*");
            }
            System.out.println();
        }

增强for循环

  • 增强for循环是jdk5引入的主要用于数组或集合的增强型for循环
  • 主要用法是用来遍历数组或集合

增强for循环语法格式如下:

    for(声明语句 : 表达式){
        //代码语句
    }

遍历输出所有数组里面的数据:

    int[] numbers = {10,20,30,40,50};//定义数组
  
    for（int x：numbers）{
        System.out.println(x);
    }

break、continue

break与continue可以用在任何循环中

  • break用于强制退出循环
    int i = 0;
    while (i<100){
        i++;
        System.out.println(i);
        if(i==30){
            break; //输出到30就退出
        }
    }
  • continue用于终止某次循环,然后进行下一次循环
    int i = 0;
    while (i<100){
        i++;
        if(i%10==0){
            System.out.println();
            continue; //不输出与10取余的数
        }
        System.out.println(i);
    }

continue扩展(不建议使用,了解即可)

    //打印100~150之间的质数
    int count = 0;
  
    outer: for(int i = 101;i < 150;i++){
        for(int j = 2;j < i/2;j++){
            if (i % j == 0) {
                continue outer;    //通过outer标签直接跳转外循环  
            }
        }
        System.out.print(i+" ");
    }

方法

什么是方法

  • 方法是语句的集合,它们在一起执行一个功能
  • 方法包含于类或对象中
  • 方法在程序中被创建,在其他地方被引用
  • 方法的命名规则: 首字母小写,后面驼峰命名
    public class Demo{
        public static void main(String[] args){
            int sum = add(1,2);
            System.out.println(sum);
        }
  
        //加法的方法add
        public static int add (int a,int b){
            return a+b;
        }
    }

方法的定义

  • 方法类似于其它语言的函数,是一段用来完成特定功能的代码片段
  • 一般情况下定义一个方法包含以下语法: 方法包含一个方法头和一个方法体

下面是一个方法的所有部分:

  1. 修饰符:这是可选的,告诉编译器该如何调用该方法.定义了该方法的访问类型.
  2. 返回值类型:方法可能会返回值.returnBaleType是方法返回值法数据类型,有些方法执行所需的操作,但没有返回值.在这种情况下returnValeType是关键字void.
  3. 方法名:是方法的实际名称.方法名和参数表共同构成方法签名.
  4. 参数类型:参数像是一个占位符,当方法被调用时,传递值给参数.这个值被称为实参或变量.参数列表是指方法的参数类型、顺序和参数的个数.参数是可选的,方法可以不包含参数. 形式参数:在方法被调用时用于接收外界输入的数据. 实参:调用方法时实际传给方法的数据.
    public class Demo{
        public static void main(String[] args){
        //实际参数:实际用来调用的参数
            int sum = add(1,2);      
            System.out.println(sum);
        }
        //形式参数:用来定义作用的
        public static int add(int a,int b){
            return a+b;
        }
    }
  1. 方法体:方法体包含具体的语句,定义该方法的功能.

方法的调用

  • 调用方法:对象名.方法名(实惨列表)
  • Java支持两种调用的方式,根据方法是否返回值来选择.
  • 当方法返回一个值时,方法调用通常被当作一个值. 例如:
    int larger = max(30,40);
  • 如果方法返回值是void,方法调用一定是一条语句.

方法的重载

重载就是在一个类中,有相同的函数名,但形参不同的函数

    public static double max(double num1,double num2){
    }
    public static int max(int num1,int num2){
    }

方法的重载规则:

  • 方法名必须相同
  • 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)
  • 方法的返回值类型可以相同也可以不同
  • 仅仅返回值类型不同不足以成为方法的重载

命令行传参(扩展)

main方法也可以传递参数

    package FuXi002;

public class Demo4 {
    public static void main(String[] args) {
        //args.length 数组长度
        for(int i = 0;i < args.length; i++){
            System.out.println("args["+i+"]"+args[i]);
        }
    }
}

命令行: MingLingHangChuanCan

可变参数

  • 也叫做不定项参数,在JDK1.5开始,Java支持传递同类型的可变参数给一个方法
  • 在方法声明后,在指定参数类型后加一个省略号(...)
  • 一个方法中只能指定一个可变参数,它必须是方法的最后一个参数,任何普通的参数必须在它之前声明
    public class Demo {
        public static void main(String[] args){
            Demo demo = new Demo();
            demo.test(1,2,3,4,5);
        }
  
        public void test(int... i){
            System.out.printlln(i[0]);
            System.out.printlln(i[1]);
        }
    }

找出最大的数

    public class Demo{
        public static void main(String[] args){
      
        }
  
        public static void printMax(double... numbers){
            if(number.length == 0){
                System.out.println("No argument passed");
                return;
            }
      
            double result = numbers[0];
      
            //排序
            for(int i=1;i<numbers.length;i++){
                if(numbers[i]> result) {
                    result = numbers[i];
                }
            }
            System.out.println("The max value is" + result);
        }
    }

递归

  • 递归就是A方法自己调用A方法
  • 使用递归可以用简单的程序来解决一些复杂的问题.它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解.递归策略只需少量的程序就可描述出解题所需要的多次重复计算,大大地减少了程序的代码量.递归的能力在于用有限的语句来定义对象的无限集合.
  • 递归结构包括两个部分
  1. 递归头: 什么时候不调用自身方法.如果没有头,将陷入死循环.
  2. 递归体:什么时候需要调用自身方法.
    public class Demo{
        public static void main(){
            System.out.println(f(5));
        }
        //1的阶乘是它本身
        //2的阶乘是2*1
        //5的阶乘是5*4*2*1
  
        //2: 2*f(1)
        public static int f(int n){ //返回n的阶乘
      
            if(n == 1){
                return 1;
            } else {
                return n*f(n-1);
            }
      
        }
    }

数组

  1. 数组是相同类型的有序集合
  2. 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成
  3. 每一个数据称做一个数组元素,每个数组元素可以通过一个下标来访问它们

数组的声明创建

首先必须声明数组变量,才能在程序中使用数组,下面是声明数组变量的语法

public class Demo {
    public static void main{
        int[] nums ;//1.定义
        nums = new int[10]; //可以存放10个int类型的数字
  
        //给数组中元素复制
        nums[0] = 0;
        mums[1] = 1;
        mums[2] = 2;
        mums[3] = 3;
  
        System.out.println(nums[0]);//输出0
        System.out.println(num[4]);//int默认为0
  
      //所有元素的和
      int sum = 0;
  
      //获取数组长度:arrays.length
      for(int i = 0;i<nums.length;i++){ 
        sum += nums[i];
      }  
  
    }
}

三种初始化

静态初始化与动态初始化

    public class Demo{
        public static void main(String[] args){
            //静态初始化 : 创建 + 赋值
            int[] a = {1,2,3,4,5,6,7,8};
            System.out.println(a[0]);
      
            //动态初始化 : 包含默认初始化
            int[] b = new int[10];
            b[0] = 10;
            System.out.println(b[0]);
            System.out.println(b[1]);
  
        }
    }

数组的四个特点

  1. 其长度必须是确定的,数组一旦被创建,它的大小就是不可改变的.
  2. 其元素必须是相同类型,不允许出现混合类型
  3. 数组中的元素可以是任何数据类型,包括基本类型和引用类型.
  4. 数组变量属于引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量.数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的.

数组边界

  • 下标的合法区间是[0,length-1],如果越界就会报错;
  • ArraylndexOutOfBoundsException:数组下标越界异常!

小结

  • 数组是相同数据类型(数据类型可以为任意类型)的有序集合
  • 数组也是对象.数组元素相当于对象的成员变量
  • 数组长度是确定的,不可变的.如果越界,则报错:ArraylndexOutofBounds

数组的使用

  • For循环
  • For - Each循环
  • 数组作方法入参
  • 数组作返回值
    public class Demo{
        public static void main(){
        //所有元素的和
            int[] arrays = {1,2,3,4,5};
      
            //打印全部的数组元素
            for (int i = 0;i < arrays.length ;i++) {
                sum += arrays[i];
            }
            System.out.print("sum="+sum);
  
            //查找最大元素
            int max = arrays[0];
      
            for(int i = 0;i < arrays.length; i++){
                if(arrays[i]>max){
                    max = array[i]
                }
            }
            System.out.println("max="+max);
        }
  
  
        //For - Each 循环
        //打印所有数组元素:
        public static void printArray(int[] arrays){
            for(int i = 0;i<arrays.length; i++){
                System.out.print(arrays[i]+" ");
            }
        }
  
        //反转数组
        public static int[] reverse(int[] arrays){
            int[] result = new int[arrays.length];
      
            //反转操作
            for(int i=0;i<resout,length-1;i<arrays.length;i++,j--){
                result[j] = arrays[i];
            }
            return result;
      
            printArray(reverse);
        }
    }

多维数组

    public class Demo{
        public static void main(String[] args){
            int[][] array = {{1,2},{2,3},{4,5}};
      
            System.out.print(array.length);
            printArray(array[0][0]);
            System.out.print(array[0][1]);
      
            for(int i = 0;i < array.length ;i++){
                for(int j = 0;j < array.length ;j++) {
                    System.out.println(array[i][j]);
                }
            }
      
        }
  
        //打印所有数组元素:
        public static void printArray(int[] arrays){
            for(int i = 0;i<arrays.length; i++){
                System.out.print(arrays[i]+" ");
            }
        }
  
    }

Arrays类

  • 数组的工具类 : java.util.Arrays： 包含操作数组的各种方法，里面的方法可以直接调用

    
import java.utrl.Arrays;//工具类

public class Demo {
  public static void main(String[] args){

    int[] a = {1,2,3,4,9090,31231};
    System.out.println(a); //输出哈希值
    System.out.println(Arrays.toString(a));
    Arrays.sort(a);//排序
    System.out.println(Arrays.toString(a));
  }

  public static void printArray(int[] a){
    for (int i = 0;i < a.length;i++){
      if(i==0){
      System.out.print(a[i]+",");

    }else{
      System.out.print(a[i]+",");
      }
    }
  }
}

冒泡排序

import java.utrl.Arrays;

public class Demo{
  public static void maim(String[] args){
    int[] a = {1,4,3,5,7,8,2,9,6}
    int[] sort = sort(a);//调用排序算法返回排序后的数组
    System.out.println(Array.toString(sort));
  }
//冒泡排序
//1.比较数组中两个相邻的元素，如果第一个数比第二个数大，就交换它们的位置
//2.每一次比较，都会产生出一个最大，或者最小的数字
//3.下一轮则可以少一次排序
//4.依次循环，直到结束

  public static void sort(int[] array){
    //临时变量
    int temp = 0;
    //外层循环，判断我们这个循环要走多少次
    for(int i = 0; i < array.length-1;i++){
      //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
      for(int j = 0;j < array.length-1-i;j++){ 
        if (array[j+1] < array[j]) {
          temp = array[j];
          array[j] = array[j+1];
          array[j+1] = temp;
        }
      }
    }
  }
  return array;
}

稀疏数组

  • 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
  • 稀疏数组一共有几行几列，有多少个不同值
  • 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
  • 如下图：左面是原始数组，右面是稀疏数组

xssz

[0] : 6行7列，里面有8个有效数字

[1] ~ [8] ：有效数字坐标与值

  • 代码展示：
public class ArrayDemo {
  public static void main(String[] args) {
    //一. 创建二维数组 0 ：没有棋子， 1 ：黑棋  2 ：白棋
    int[][] array1 = new int[11][11];
    array1[1][2] = 1:
    array1[2][3] = 2;
    //输出原始数组
    for(int[] ints : array1){
      for(int anInt : ints) {
        System.out.print(anInt+"\t");
      }
      System.out.println();
    }
 
    System.out.println("======================");

    //转换为稀疏数组保存
    //获取有效值的个数
    int sum = 0;
    for(int i = 0;j < 11;j++) {
      for(int j = 0;j < 11; j++){
        if(array1[i][j]!=0){
          sum++;
        }
      }
    }
    System.out.println("有效值个数:"+sum);
    //二.创建一个稀疏数组的数组
    int[][] array2 = new int[num+1][3];
    array2[0][0]= 11;
    array2[0][1]= 11;
    array2[0][2]= sum;
    遍历二维数组，将非0的值，存入稀疏数组中
    int count = 0;
    for (iny i = 0;i < array.length ; i++) {
      for(int j = 0; j < array1[]; j++) {
        if(array1[i][j]!=0){
          count++;
          array2[count][0] = i;
          array2[count][1] = j;
          array2[count][2] = array[i][j];
        }
      }
    }
    //输出稀疏数组
    System.out.println("稀疏数组");
    for (int i = 0; i < array.length; i++){
      System.out.println(array2[i][0]+"\t"
              +array2[i][1]+"\t"
              +array2[i][2]+"\t");
    }
    System.out.println("=========================");
    System.out.println("还原");
    //1.读取稀疏数组
    int[][] array3 = new int[array2[0][0]][array2[0][1]];

    //2.给其中的元素还原它的值
    for(int i = 1;i < array2.length; i++) {
      array3[array2[i][0]][array2[i][1]] = array2[i][2];
    }

    //3.打印
    System.out.println("输出原始的数组")；

    for(int[] ints : array1) {
      for(int anInt : ints) {
        System.out.print(anInt+"\t");
      }
      System.out.println();
    }
  
  }
}

面向对象编程

面向过程&面向对象

  • 面向过程思想：

    1. 步骤清晰简单 ：第一步-->第二步
    2. 面向过程适合处一些较为简单的问题

  • 面向对象思想：

    1. 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，再对某个分类下的细节进行面向过程的思索。
    2. 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

  • 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，任然需要面向过程的思路去处理。

什么是面向对象

  • 面向对象编程（Object-Oriented Programming : OOP）

  • 面向对象编程的本质：以类的方式组织代码，以对象的方式组织(封装)数据。

  • 抽象

  • 三大特性：

    1. 封装
    2. 继承
    3. 多态

  • 从认识论角度考虑是先有对象后有类。对象是具体的事物。类是抽象的，是对对象的抽象

  • 从代码运行角度考虑是先有类后有对象。类是对象的模板。

— 感谢你读到这里 —

愿这些文字，给你带来一点启发。

下一篇在代码与生活之间，留一片自己的小天地