Java基础复习-优快云博客

本文链接：https://blog.youkuaiyun.com/zhengdatao126/article/details/114706426

重温Java3

Scanner对象

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

        System.out.println("使用next方法接收：");
        if(sa.hasNext()){//判断用户有没有输入字符串
            String str = sa.next(); //使用next方法接收
            System.out.println("输出内容为："+str);
        }
        //凡是属于IO流的类如果不关闭会一直占用资源，用完就关闭！
        sa.close();
结果：
		使用next方法接收：
        hello world
        输出内容为：hello
----------------------------------------------------------------------    
    	//创建一个扫描器对象，用于接收键盘数据
        Scanner sa = new Scanner(System.in);

        System.out.println("使用next方法接收：");
        if(sa.hasNextLine()){//判断用户有没有输入字符串
            String str = sa.nextLine(); //使用next方法接收
            System.out.println("输出内容为："+str);
        }
        //凡是属于IO流的类如果不关闭会一直占用资源，用完就关闭！
        sa.close();
结果：
        使用next方法接收：
        hello world！
        输出内容为：hello world！

next():
1. 一定要读取到有效字符后才可以结束输入。
2. 对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4. next()不能得到带有空格的字符串
nextLine():
1. 以Enter为结束符，也就是nextLine() 方法返回的是输入回车之前的所有字符。
2. 可以获得空白。

while与 do…while循环

while是最基本的循环，只要布尔表达式为true，循环就会一直执行下去。
大部分情况下会让循环停下来，需要一个让表达式失效的方式来结束循环。
循环条件为true会造成无限循环【死循环】，正常业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死奔溃！
do…while 循环和while循环相似，不同的是，do…while循环至少会执行一次。
while和do-while的区别：
1. while先判断后执行。dowhile是先执行后判读！
2. Do…while总是保证循环体会至少被执行一次！这是他们的主差别。

for循环

for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。
for循环执行的次数是在执行前就不确定的。

语法格式：for（初始化；布尔表达式；更新）{ 代码语句 }
增强for循环主要用于数组或集合

语法格式：for（声明语句：表达式）{ 代码句子 }
1. 声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
2. 表达式是要访问的数组名，或者是返回值为数组的方法。
```
		int [] numbers = {10,20,30,40,50};
        for (int x:
             numbers) {
            System.out.println(x);
        }
```

方法重载

重载是在一个类中，有相同的函数名称，但形参不同的函数。
方法重载的规则：
1. 方法名称必须相同
2. 参数列表必须不同（个数、类型、或者参数排列顺序不同等）。
3. 方法的返回类型可以相同也可以不同。
4. 仅仅返回类型不同不足以成为方法的重载。

递归

递归就是：方法A调用方法A！就是自己调用自己
递归可以用简单的程序来解决一些复杂的问题。只需少量的程序就可以描述出解题过程所需要的多次重复计算，大大减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

递归结果有两个部分：

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

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

	//递归
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    //计算阶乘5
    public static int f(int n){
        int a =0;
        if(n==1){
            return 1;
        }else{
            a = n*f(n-1);
            return a;
        }
    }

数组

数据的先声明，才能使用：数组类型 [] 数组名或数组类型数组名 [] 。
java语言使用new操作符来创建数组：int [] a = new int[9]。
数组通过索引来访问，从0开始。
数组的长度是在创建的时候就固定的，获取数组的长度：数据名.length 如 a.length
元素必须相同，不允许出现混合类型。
数组长度是确定的，不可变，如果越界，则报：ArrayIndexOutofBounds
数组也是对象，数组元素相当于成员变量，是有序集合。

Java内存分析

在这里插入图片描述

在声明的时候，实际是在栈里面创建了一个对象，此时在堆里面是没有创建的。int [] a;
在创建的时候，实际上是在堆里面创建a的内存，a里面有数组长度的空间，里面的值为默认值。a= new int[10];
给数组里面放值，才是在堆a里面的对于索引位，放入值。 a.[8]=8;

冒泡排序

	public static void main(String[] args) {
        //冒泡排序
        int [] a = {8,56,42,22,89,77};
        int [] b = sort(a);
        System.out.println("a --:"+ Arrays.toString(a));
        System.out.println("b --:"+Arrays.toString(b));
    }

    public static int[] sort(int [] array){
        int temp =0;
        for (int i = 0; i < array.length; 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;
    }