Java学习笔记

Striver！

于 2021-03-27 21:46:03 发布

阅读量102

点赞数

分类专栏： Java 文章标签： java 编程语言

本文链接：https://blog.csdn.net/qq_44878777/article/details/115272433

版权

Java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Java学习

入门学习

Hello World的编写

public class Hello {
	public static void main(String[]){
		System.out.print("Hello!我会在CSDN分享学Java的笔记");
	}
}

基础语法：

1.注释、标识符、关键字：

单行注释：
```
//输出Hello,World！
```
多行注释：
```
/* 注释文字 */
```
文档注释:
```
/** */
```
关键字:

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符
- 所有的标识符都应该以字母，美元符($)或者下划线（_）开始
- 不得使用关键字作为变量名和方法
- 标识符大小写敏感的

2.数据类型：

强类型语言：

要求变量的使用要严格符合规定，所有变量都必选先定义才能使用
弱类型语言：

VB，JavaScript
基本类型(primitive type)：

1.数值类型：整数类型(byte、short、int、long)、浮点类型(float、double)、字符类型（char）最好完全避免使用浮点数进行比较

2.boolean类型:只有true和false

引用类型(reference type)：类、接口、数组

public class Demo01 {
    public static void main(String[] args) {
        String AKA="憨八龟";
        System.out.println(AKA);
        //八大数据类型

        //整数
        int num1=10;
        byte num2=126;
        short num3=1000;
        long num4=30555555555555555L;//long类型得在数字后面加个L
        //小数：浮点数
        float num5 =5.1F;
        double num6=5.2222;
        //字符
        char name='M';
        //字符串,String不是关键字，类
        //String name1="憨八龟";
        //布尔值:是非
        boolean flag = true;
        boolean flag1=false;

    }
}
public class Demo02 {
    public static void main(String[] args) {
        //整数拓展：进制  二进制0b   十进制    八进制0   十六进制0x
        int i =10;
        int i2 =010;
        int i3 =0x10;//0-9 A-F
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("++++++++++++++++++++++++++++++++++++++++++++++++++++++");

        //浮点数拓展
        //BigDecimal 数学工具类
        //float 有限 离散 大约
        //最好完全避免浮点数进行比较
        float f =0.1F;//0.1
        double d=1.0/10;//0.1
        float d1=222222222222F;
        float d2=d1+1;
        System.out.println(d1==d2);
        System.out.println("++++++++++++++++++++++++++++++++++++++++++++++++");

        //字符扩展
        char c='m';
        char c1='给';
        System.out.println(c);
        System.out.println((int)c);//强制转换类型
        System.out.println(c1);
        System.out.println((int)c1);
        //所有的字符本质还是数字
        //转义字符 \t 制表符  \n 换行
    }
}

3.类型转换：

由于Java是强类型语言，所以进行有些运算的时候需要用到类型转换

低----------------------------------->高

byte,short,char–>int–>float–>double

运算重，不同类型的数据先转化为同一类型，然后进行运算

强制类型转换：强制转换（类型）变量名（高–>低）

自动类型转换：（低–>高）

public class Demo03 {
    public static void main(String[] args) {
        int i = 128;
        byte b= (byte)i;//内存溢出
        double h=i;
        //强制转换 （类型）变量名 高-->低
        //自动转换 低-->高
        System.out.println(i);
        System.out.println(b);
        System.out.println(h);
        System.out.println("++++++++++++++++++++++++");
        System.out.println((int)25.3);
        System.out.println((int)-45.1f);
        System.out.println("++++++++++++++++++");
        char c='a';
        int d=c+1;
        System.out.println((char) d);
    }
}
    注意点：
1.不能对布尔值进行转换；
2.不能把对象类型转换为不相关的类型
3.高容量转低容量，强制转换
4.转换的时候可能内存溢出，或者精度问题

4.变量、常量：

变量就是可以变化的量

Java是一种强类型的语言，每个变量都得声明类型

Java变量是程序中最基本的存储单元，其要素包含变量名，变量类型和作用域

注意事项：
- 每个变量都有类型，类型可以是基本类型或者引用类型
- 变量名必须是合法的标识符
- 变量声明是一条完整的语句，声明以分号结束
```
type varName [=value] [{,varName[=value]}];
//数据类型 变量名 = 值； 可以使用逗号隔开来声明多个同类型变量
```

变量作用域：类变量、实例变量、局部变量

final 常量名=值
final double PI=3.14 //常量：初始化后不能再改变值，一般使用大写字符。

变量命名规范：

所有变量、方法、类名：见名知意；
类成员变量：首字母小写和驼峰原则；
局部变量：首字母小写和驼峰原则；
常量：大写字母和下划线：MAX_VALUE;
类名：首字母大写和驼峰原则；
方法名：首字母小写和驼峰原则；

public class Demo04 {
    public static void main(String[] args) {
        int a=1,b=2,c=3;
        String name="Mandalo";
        char x ='X';
        double pi=3.14;

    }
}

public class Demo05 {
    //类变量 static
    static double salary =2500;
    static final double PI=3.14;
    //属性：变量
    //实例变量：从属于对象;如果不自行初始化，类型的默认值0 0.0
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;
    //main 方法
    public static void main(String[] args) {
        //局部变量:必须声明和初始化值
        int i=10;
        System.out.println(i);
        Demo05 demo05 =new Demo05();
        System.out.println(demo05.age);
        System.out.println(demo05.name);
        System.out.println(salary);
        System.out.println(PI);

    }


    public void add(){

    }
}

5.运算符：

package operator;

public class Demo01 {
    public static void main(String[] args) {
        int a =10;
        int b =20;
        int f=21;
        long c =123131431421L;
        short d=12;
        byte e=8;
        System.out.println(a/(double)b);
        System.out.println(b+c+d+e);//Long
        System.out.println(d+e+a);//int
        System.out.println(d+e);//int
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(f%a);//取余
    }
}

package operator;

public class Demo02 {
    public static void main(String[] args) {
        //++ 自增 --自减    一元运算符
        int a=3;
        int b=a++;//执行完这行代码后，先给b赋值再自增
        //a = a + 1
        System.out.println(a);
        //a++ a = a + 1
        int c=++a; //执行完代码前先自增，再给b赋值
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        double pow =Math.pow(2,3);//幂运算
        System.out.println(pow);
    }
}

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //逻辑运算符
        //与(and) 或(or) 非(取反)
        boolean a =true;
        boolean b=false;
        System.out.println("a && b");//逻辑与运算
        System.out.println("a || b");//逻辑或运算
        System.out.println("!(a && b):"+!(a&&b));//如果时真，则变为假，如果师加则为真
        //短路运算
        int c= 5;
        boolean d=(c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);
    }
}

package operator;

public class Demo04 {
    public static void main(String[] args) {
        /*
        * A = 0011 1100
        * B = 0000 1101
        * --------------
        * A&B 0000 1100
        * A|B 0011 1101
        * A^B 0011 0001
        * ~B  1111 0010
        * 位运算效率极高
        * << *2
        * >> /2
        *
        * */
        System.out.println(2<<3);

    }
}

package operator;

public class Demo05 {
    public static void main(String[] args) {
        int a =10;
        int b =20;
        //字符串连接符 + , String
        System.out.println(""+a+b);//字符串在前面会拼接
        System.out.println(a+b+"");//字符串在后面会运算
        //三元运算符
        int score = 80;
        String type = score <60?"不及格":"及格";
        System.out.println(type);
    }
}

6.包机制、JavaDoc:

为了更好地组织类，Java提供包机制，用于区别类名的命名空间（本质就是文件夹）
一般利用公司域名倒置作为域名
packa必须放在最上面

JavaDoc命令是用来生成自己API文档的，加在类上=类注释，加在代码上=代码注释

package base;

/**
 * @author Mandalo
 * @version 1.8
 *
 */
public class Doc {
    String name;

    /**
     *
     * @param name
     * @return
     * @throws Exception
     */
    public String test (String name)throws Exception{
        return name;

    }
}

···

Java流程控制:

1.用户交互Scanner：

通过Scanner类来获取用户的输入
通过Scanner类的next()与nextLine()方法获取输入的字符串，读取前用hasNext()与hasNextLine()判读是否还有输入的数据
next():

一定要读取到有效字符后才结束；有效字符前的空白，next（）会自动将其去掉；只有输入有效字符后才将后面输入的空白作为分隔或结束符；next()不能得到带有空格的字符串

nextLine():

以Enter为结束符也就是说nextLine()方法返回的是输入回车之前的所有字符;可以获得空白

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收：");
        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            //使用next方式接收
            String str = scanner.next();//程序等待用户输入完毕
            System.out.println("输出的内容为："+str);
        }
        scanner.close();
        // I/O流的类如果不关闭会占用资源
    }
}

public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner =new Scanner(System.in);
        int i =0;
        float f = 0.0f;
        System.out.println("请输入整数");
        if (scanner.hasNextInt()){
            i = scanner.nextInt();
            System.out.println("整数数据："+i);
        }
        else {
            System.out.println("输入的不是整数数据！");
        }
        if (scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小数数据："+f);
        }
        else {
            System.out.println("输入的不是小鼠数据！");
        }


        scanner.close();
    }
}

public class Demo03 {
    public static void main(String[] args) {
        //我们输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果
        Scanner scanner = new Scanner(System.in);
        double sum = 0;
        //计算输入了多少个数字
        int m = 0;
        //通过循环判断是否还有输入，并在里面对每一次进行求和和统计
        while (scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            m = m++;
            sum = sum + x;
            System.out.println("当前的和为："+sum);
        }
        System.out.println(m + "个数的和为" + sum);
        System.out.println(m + "个数的平均值是" + (sum / m));
        scanner.close();
    }
}

2.顺序结构

顺序结构是最简单的算法结构，由若干个依次执行的处理步骤组成的；是任何一个算法都离不开的一种基本算法结构

public class Demo01 {
    public static void main(String[] args) {
        System.out.println("hello1");
        System.out.println("hello2");
        System.out.println("hello3");
        System.out.println("hello4");
        System.out.println("hello5");
    }
}

3.选择结构✨

if单选择结构

if(布尔表达式){
    //布尔表达式为true将执行的语句
}

public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        //equals:比较字符串是否相等
        if (s.equals("Hello")){
            System.out.println(s);
        }
        System.out.println("End");
        scanner.close();
    }
}

if双选择结构

if（布尔表达式）{
   //表达式为true 
}else{
    
}
public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score=scanner.nextInt();
        if (score>=60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        scanner.close();
    }
}

if多选择结构

if(){
 
}else if{
    
}else{
    
}
ublic class Demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score=scanner.nextInt();
        /**
         * if 语句至少有1个else语句，else语句在所有的else if语句之后
         * if语句可以有若干个else if语句，必须在else语句之前
         * 其中一个else if语句检测为true，其他else if以及 else语句都将跳过执行
         */
        if (score<60){
            System.out.println("不及格");
        }else if (score>60 && score<=70){
            System.out.println("普通");
        }else if (score>70 && score<90){
            System.out.println("良");
        }else{
            System.out.println("优");
        }

        scanner.close();
    }
}

嵌套的if结构

if(布尔表达式1){
    //表达式1值为true的代码
    if(布尔表达式2){
        //表达式2值为true的代码
    }
}

switch多选择结构

switch case 语句判断一个变量与一系列中某个值是否相等，每个值称为分支；变量类型：byte、short、int、char、String同时case标签必须为字符串常量或字面量

switch(expression){
    case value:
        break;
    case value:
        break;
}
public class Demo04 {
    //反编译 java---class(字节码文件)---反编译(IDEA)
    public static void main(String[] args) {
        char grade = 'D';
        switch (grade){
            case 'A':
                System.out.println("优");
                break;
            case 'B':
                System.out.println("良");
                break;
            case 'C':
                System.out.println("一般");
                break;
            case 'D':
                System.out.println("回家养猪");
                break;
        }
    }
}

4.循环结构

while 循环:

while(布尔表达式){
    //循环内容
}
public class Demo05 {
    public static void main(String[] args) {
        
        int i =0;
        int sum=0;
        while(i<=100){
            sum=sum+i;
            i++;
            System.out.println(sum);
        }
    }
}

主动让循环停止下来需要一个让表达式失效的方式

do …while 循环:对于while语句而言，不满足条件则不能进入循环，但有时候我们需要即使不满足条件也至少执行一次；

while跟do …while区别：whilie先判断后执行，do…while先执行后判断；do…while总是保证循环会被至少执行一次

do {
    //代码
}
while(布尔表达式)
    public class Demo06 {
    public static void main(String[] args) {
        int i=0;
        int sum=0;
        do {
            sum=sum+i;
            i++;
        }while (i<=100);
        System.out.println(sum);
    }
}

for循环

for循环是支持迭代的一种通用结构，是最有效、最灵活>的循环结构

for循环执行的次数最初就确定了，语法如下：

1.计算1-100之间的奇数和偶数的和

2.计算1-1000之间能被5整除的数，并且每行输出3个

3.九九乘法表

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

//计算1-100之间的奇数和偶数的和
public class Demo07 {
    public static void main(String[] args) {
        int oddsum=0;
        int evensum=0;
        for (int i=1;i<=100;i++){
            if(i%2!=0){//判断是否为奇偶数
                oddsum+=i;
            }else {
                evensum+=i;
            }

        }
        System.out.println("奇数和为："+oddsum);
        System.out.println("偶数和为："+evensum);
    }
}

//计算1-1000之间能被5整除的数，并且每行输出3个
public class Demo08 {
    public static void main(String[] args) {

        for (int i=0;i<=1000;i++){
            if(i%5==0){
                System.out.print(i+"\t");
            }
            if (i%(5*3)==0){
                System.out.println();
            }//println 输出完会换行
            //print 输出完不会换行

        }
    }
}

//九九乘法表
public class Demo09 {
    public static void main(String[] args) {
        for (int i=1;i<=9;i++){//外循环控制行数
            for (int j=1;j <= i;j++){//内循环控制每行列数
                System.out.print(i+"*"+j+"="+i*j+"\t");
            }
            System.out.println();
        }
    }
}

5.break&continue

break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强制退出循环不执行循环中剩余的语句

continue语句用在循环语句体中，用于终止某次循环过程即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定

//break
public class Demo10 {
    /**public static void main(String[] args) {
        int i =0;
        while(i<=100){
            i++;
            System.out.println(i);
            if (i==30){
                break;
            }

        }
    }*/
    //continue
    public static void main(String[] args) {
        int j=0;
        while (j<100){
            j++;
            if (j%10==0){
                System.out.println();
                continue;
            }
            System.out.print(j);
        }
    }
}

打印等腰三角形

public class Demo11 {
    public static void main(String[] args) {
        for(int i=1;i<=5;i++){
            for(int j=5; i<=j; 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();
        }

    }
}

Java的方法：

1.什么是方法

Java方法是语句的集合，它们在一起执行一个功能

方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用
设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合，最好保持方法的原子性，就是一个方法只完成1个功能，利于后期的扩展

2.方法的定义及调用

方法是一段用来完成特定功能的代码片段

方法包含一个方法头和一个方法体：

修饰符：告诉编译器如何调用该方法。定义该方法的访问类型
返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下returnValueType是关键字void
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：当方法被调用时传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型

形式参数：在方法被调用时用于接收外界输入的数据

实参：调用方法时实际传给方法的数据

方法体：方法包含具体的语句，定义该方法的功能

package method;

public class Demo01 {
    public static void main(String[] args) {
    //    int sum=add(1,2);
     //   System.out.println(sum);
        test();

    }
    //加法
    public static int add(int a,int b){
        return a+b;
    }
    public static void test(){
        for (int i=0;i<=1000;i++){
            if(i%5==0){
                System.out.print(i+"\t");
            }
            if (i%(5*3)==0){
                System.out.println();
            }//println 输出完会换行
            //print 输出完不会换行

        }
    }
}

3.方法重载

重载就是在一个类中，有着相同的函数名称，但形参不同的函数
重载的规则：

方法名称必须相同：

参数列表必须不同（个数不同或类型不同、参数排列顺序不同）：

方法的返回类型可以相同也可以不相同

仅仅返回类型不同不足以称为方法的重载

4.命令行传参

运行程序时再传递一个消息，就需要传递命令行参数给main（）函数实现

package method;

public class commandLine {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i+"]"+args[i]);
            
        }
    }
}

5.可变参数

在方法声明中，在指定参数类型后加一个省略号（…）

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明

public class Demo04 {
    public static void main(String[] args) {
        //调用可变参数的方法
        printMax(34,35,23,51,2.2);
        printMax(new double[]{1,2,3});
    }
    public static void printMax(double...numbers) {
        if (numbers.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);

    }
}

6.递归

递归：A方法调用A方法，自己调用自己
递归通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归大大减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合

递归结构部分：

递归头：什么时候不调用自身方法。如果没有头，将陷入死循环

递归体：什么时候需要调用自身方法

//递归
public class Demo05 {
    public static void main(String[] args) {
        System.out.println(f(6));
    }
    public  static int f(int n){
        if (n==1){
            return 1;
        }
        else {
            return n*f(n-1);
        }
        /**边界条件：边界
         * 前阶段：
         * 返回阶段 n*(n-1)
         */
    }
}

//计算器
public class Demo06 {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.println("请输入第一个数");
            double a= scanner.nextDouble();
            System.out.println("请输入运算符");
            String type = scanner.next();
            System.out.println("请输入第二个数");
            double b= scanner.nextDouble();
            double c=0;
            switch (type){
                case "+":
                    c = a+b;
                    System.out.println("值为：" +c);
                    continue;
                case "-":
                    c = a-b;
                    System.out.println("值为："+c);
                    continue;
                case "*":
                    c = a*b;
                    System.out.println("值为:"+c);
                    continue;
                case "%":
                    c = a%b;
                    System.out.println("值为:"+c);
                    continue;
                default:
                    System.out.println("无效的运算符");

            }

        }

    }

数组：

1.什么是数组：

数组是相同类型数据的有序集合
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合
每一个数组称为一个数组元素，每个数组元素可以通过一个下标来访问

2.数组的声明与创建：

dataType[] arrayRefVar;
dataType arrayRefVar[];
dataType[] arrayRefVar = new dataType[arraySize]

数组是通过索引来访问的，索引从0开始；

静态初始化：

int[] a= {1,2,3};
Man[] mans ={new Man(1,1).new Man(2,3)};

动态初始化：

int[] a=new int[2];
a[0]=1;
a[1]=2;

数组的四个基本特点：

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

3.数组的使用：

for-each循环
数组做方法入参
数组做返回值

public class Demo03 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};
        //for (int array : arrays) {
           // System.out.println(array);

        //}
        int[] reverse = reverse(arrays);
        printArraty(reverse);
    }
    //打印数组元素
    public static void printArraty(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,j=result.length-1;i< arrays.length;i++,j--){
            result[j]=arrays[i];
        }
        return result;

    }
}

public class Demo02 {
    //
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};
        //打印数组元素
        for(int i=0;i< arrays.length;i++){
            System.out.println(i);
        }
        System.out.println("============");
        int sum=0;
        for(int i=0;i< arrays.length;i++){
            sum=sum+arrays[i];
        }
        System.out.println("sum="+sum);
        System.out.println("============");
        int max=arrays[0];
        for(int i=0;i< arrays.length;i++){
            if (arrays[i]>max){
                max=arrays[i];
            }
        }
        System.out.println("max:"+max);

    }
}

4.多维数组：

int[] [] array={{},{},{},{}};
package Array;

public class Demo04 {
    public static void main(String[] args) {
        int[] [] array = {{1,2},{3,4},{5,6},{7,8}};
        for (int i = 0; i < array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                System.out.println(array[i][j]);

            }

        }
        //printArraty(array[1]);

    }
    /**public static void printArraty(int[] arrays){
        for(int i=0;i< arrays.length;i++){
            System.out.print(arrays[i]+" ");

        }
    }*/
}

5.Arrays类讲解：

常用功能

给数组赋值：通过fill方法

对数组排序：通过sort方法（升序）

比较数组：通过equals方法比较数组中元素值是否相等

查找数组元素：通过binarySearch方法能对排序号的数组进行二次查找法操作

package Array;

import java.util.Arrays;

public class Demo06 {
    public static void main(String[] args) {
        int[] a= {1,2,51,3645,45};
        //System.out.println(Arrays.toString(a));
        //打印数组元素Array.toString
        //printArray(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("[");
            }
            if (i==a.length-1){
                System.out.print("]");
            }
            else{
                System.out.print(a[i]+"，");
            }

        }
    }
}

6.冒泡排序：

冒泡排序两层循环，外层冒泡轮数，里面依次比较

package Array;

import java.util.Arrays;

//冒泡排序
//1比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换位置
//2每一次比较都会产生一个最大，或者最小的数字
//3下一轮则可以少一次排序
//4依次循环，直到结束
public class Demo06 {
    public static void main(String[] args) {
        int[] a= {1,2,51,3645,45,254,6452,31};
        int[] sort=sort(a);//调用完自己写的排序方法以后，返回一个排序后的数组
        System.out.println(Arrays.toString(sort));

    }

    public static int[] sort(int[] array){
        //临时变量
        int temper = 0;

        //外层循环,判断要走多少次
        for (int i = 0; i < array.length-1 ; i++) {
            boolean flag = false;//减少没有意义的比较
            for (int j = 0; j < array.length-1-i ; j++) {
                if (array[j+1]>array[j]){
                    temper=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temper;
                    flag = true;
                }

            }
            if (flag==false){
                break;
            }

        }
        return array;

    }
}

7.稀疏数组：

当一个数组中的大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组

稀疏数组的处理方式是：

记录数组一共有几行几列，有多少个不同值

把具有不同值的元素何行列及值记录在一个小规模的数组中，从而缩小程序的规模

package Array;

public class Demo07 {
    public static void main(String[] args) {
        //创建一个二维数组 11*11 0：没有棋子 1：黑 2:白
        int[] [] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        //输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints:array1){
            for (int anInt:ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum =0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }

            }

        }
        System.out.println("有效值的个数："+sum);
        //创建一个稀疏数组的数组
        int[][] array2=new int[sum+1][3];
        array2[0][0] =11;
        array2[0][1] =11;
        array2[0][2] =sum;
        //遍历二维数组，将非零的值存放到稀疏数组中
        int count=0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }

            }
            
        }
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.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:array3){
            for (int anInt:ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }

}

面向对象：

1.初始面向对象：

（1）面向过程思想：

步骤清晰简单
面对过程适合处理一些较为简单的问题

（2）面向对象思想：本质是以类的方式组织代码，以对象的组织（封装）数据

物以类聚，分类的思维模式，思考问题首先会解决问题需要那些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索
面向对象适合处理复杂的问题，适合处理需要多人协作的问题
对于描述复杂的事物，为了从宏观上把握、从整体上分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理
三大特性：封装继承多态

2.方法回顾与加深：

方法的定义：

修饰符、返回类型、break（跳出 switch，结束循环）和return（方法结束）的区别、方法名（注意规范，见名知意的原则）、参数列表（参数类型，参数名）、异常抛出
方法的调用：

静态方法、非静态方法、形参和实参、值传递和引用传递、this关键字

3.对象的创建分析：

4.面向对象三大特性：

5.抽象类和接口：

6.内部类以及OOP实战：

Striver！

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Java学习笔记

Java学习入门学习Hello World的编写public class Hello { public static void main(String[]){ System.out.print("Hello World!"); }}基础语法：1.注释、标识符、关键字：单行注释：//输出Hello,World！多行注释：/* 注释文字 */文档注释:/** */关键字:Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符所有
复制链接

扫一扫