JAVASE基础回顾总结（二）

最新推荐文章于 2020-09-15 14:57:42 发布

雅静8

最新推荐文章于 2020-09-15 14:57:42 发布

阅读量481

点赞数

分类专栏： Java SE基本知识总结文章标签： java se

本文链接：https://blog.csdn.net/yajing8/article/details/72866082

版权

Java SE基本知识总结专栏收录该内容

17 篇文章 0 订阅

订阅专栏

JAVASE基础回顾总结（二）

1.运算符：
（1）面试题：s+=1 不等价于：s=s+1;而是等价于s=（s的数据类型）s+1;
（2）面试题：&和&&（|和||）区别：结果相同，但是&&（||）是短路运算；

2.选择结构if和switch如何选择？
（1）if的使用场景：

针对结果是boolean类型的判断；因为switch（byte、short、int、char、String、枚举）只能判断这几种类型；
针对一个范围的判断；
针对几个常量值的判断；

（2）switch的使用场景：

针对几个常量值的判断；

3.（1）求和思想：

定义两个变量，一个变量用于存储第一个加数，第一个加数实际上保存的是以前的所有数据和，默认初始值为0；
一个变量用于存储加数，这个变量其实就是每次数据变化的值；

4.for循环和while循环的区别：
（1）如果你想在循环结束后继续使用控制条件的那个变量，用while循环，否则使用for循环；
（2）不知道选什么时就用for循环，因为变量及早的从内存中消失，提高了内存使用效率；
（3）如果是一个范围的用for循环非常明确；如果循环次数不明确的使用while循环较为合适；

5.控制跳转语句：
（1）break:（中断）：①在switch语句中；②在循环语句中，跳出当前循环（循环语句中加入if判断的情况）③离开上面两个场景使用无意义；
（2）continue：（继续）：①在循环语句中，跳出本次循环，继续下次循环；
（3）return：（退出方法）：结束一个方法，跳转到上层调用该方法的地方，return后面的语句不执行；

6.方法的思想：
（1）方法不调用不执行；
（2）方法之间是平级关系，不能嵌套定义；

7.数组：
（1）定义：存储同一种数据类型的多个元素的容器或集合；
（2）定义格式：（此时数组还未初始化，不能使用）

①数据类型 [] 数组名；
②数据类型数组名[];

（3）数组的初始化：

定义：所谓初始化就是为数组中的数组元素分配内存空间，并为每个数组元素赋值；
初始化格式：
①动态初始化：初始化时只指定数组的长度，由系统为数组分配初始值；
数据类型 [] 数组名 = new 数据类型[数组长度]；（数组长度即数组中元素个数）
举例：int [] arr1 = new int [3]; arr[0] = 1;arr[1] = 1; arr[2] = 1;

②静态初始化：初始化时指定每个元素的初始值，由系统决定数组长度；
格式：数据类型 [] 数组名 = new 数据类型[]{值1，值2，…}
举例：int [] arr2 = new int[]{1,2,3}
简化格式：数据类型 [] 数组名 = {值1，值2，…}
举例：int [] arr2 ={1,2,3}

②错误始化化：静态和动态初始化一起使用：
格式：数据类型 [] 数组名 = new 数据类型[数组长度]{值1，值2，…}
举例：int [] arr2 = new int[3]{1,2,3}

（4）数组的遍历：
①方式一：使用for循环和数组的length属性；

（5）数组的一些操作：

①获取数组最大值：（参考代码如下）：

/*
    数组获取最值(获取数组中的最大值最小值)

        分析：
        A:定义一个数组，并对数组的元素进行静态初始化。
        B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。
        C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
        D:最后参照物里面保存的就是最大值。
*/
public class ArrayMax {
    public static void main(String[] args) {
        int arr[] = {12,56,23,21,98,14,13,100};
        System.out.println(new ArrayMax().getArrayMax(arr));

    }

    public int getArrayMax(int[] arr) {
        int max = arr[0];
        for(int i=1; i<arr.length; i++){
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

②数组元素逆序（参考代码如下：两种方式）

/*
 * 实现：数组元素逆序 (就是把元素对调)
 */
public class ArrayReverse {
public static void main(String[] args) {
    int[] arr = {1,45,32,21,67};
    //new ArrayReverse().reverseArrayOne(arr);
    new ArrayReverse().reverseArrayTwo(arr);
    for(int i=0; i<arr.length;i++){
        System.out.print(arr[i]+" ");
    }
}

/*
 * 实现一：
 *  数组元素逆序 (就是把元素对调)

        分析：
            A:定义一个数组，并进行静态初始化。
            B:思路
                把0索引和arr.length-1的数据交换
                把1索引和arr.length-2的数据交换
                ...
                只要做到arr.length/2的时候即可。
 * 
 */
public void reverseArrayOne(int[] arr) {
    int tmp;
    for(int i=0; i<arr.length/2;i++){
        tmp = arr[i];
        arr[i] = arr[arr.length-1-i];
        arr[arr.length-1-i] = tmp;

    }
}

public void reverseArrayTwo(int[] arr) {
    int tmp;
    for(int start=0,end=arr.length-1; start<end;start++,end--){
        tmp = arr[start];
        arr[start] = arr[end];
        arr[end] = tmp;

    }
}
}

③实训数组操作总结:

package com.utils;
/**
 * 数组相关的操作:
 * @author 任志燕 
 * 2017年6月20日
 *
 */
public class ArrayTest {
    /**
     * 插入排序(元素是int型的)
     * @param beforeInsertArr:int[] 排好序的数组
     * @param afterInsertArr:int[] 插入后的数组，需要定义，且需要声明长度(eg:int[] afterInsertArr = new int[beforeInsertArr+1])
     * @param type:String 取值只有两个:asc(升序)或desc(降序),指明beforeInsertArr的排序方式
     * @param num:int 待插入的数据
     * @return void
     */
    public static void insertNum(int[] beforeInsertArr,int[] afterInsertArr,String type,int num) {
        //1.将插入前的数组的值赋给插入后数组
        for (int i = 0; i < beforeInsertArr.length; i++) {
            afterInsertArr[i] = beforeInsertArr[i];
        }
        //2.默认插入数字的位置是插入后数组的最后一个位置
        int index = beforeInsertArr.length;
        //3.找插入字符的位置
        for (int i = 0; i < beforeInsertArr.length; i++) {
            if ("asc".equals(type)) {
                if (num < beforeInsertArr[i]) {
                    index = i;
                    break;
                }
            }else if ("desc".equals(type)) {
                if (num > beforeInsertArr[i]) {
                    index = i;
                    break;
                }
            }
        }
        //4.将插入字符位置以后的元素后移
        for (int i = afterInsertArr.length-1; i > index; i--) {
            afterInsertArr[i] = afterInsertArr[i-1];
        }
        afterInsertArr[index] = num;
    }

    /**
     * 插入排序(元素是char型的)
     * @param beforeInsertArr:char[] 排好序的数组
     * @param afterInsertArr:char[] 插入后的数组，需要定义，且需要声明长度(eg:char[] afterInsertArr = new char[beforeInsertArr+1])
     * @param type:String 取值只有两个:asc(升序)或desc(降序),指明beforeInsertArr的排序方式
     * @param :character char 待插入的数据
     * @return void
     */
    public static void insertChar(char[] beforeInsertArr,char[] afterInsertArr,String type,char character) {
        for (int i = 0; i < beforeInsertArr.length; i++) {
            afterInsertArr[i] = beforeInsertArr[i];
        }
        int index = beforeInsertArr.length;
        for (int i = 0; i < beforeInsertArr.length; i++) {
            if ("asc".equals(type)) {
                if (character < beforeInsertArr[i]) {
                    index = i;
                    break;
                }
            }else if ("desc".equals(type)) {
                if (character > beforeInsertArr[i]) {
                    index = i;
                    break;
                }
            }
        }
        for (int i = afterInsertArr.length-1; i > index; i--) {
            afterInsertArr[i] = afterInsertArr[i-1];
        }
        afterInsertArr[index] = character;
    }
    /**
     * 求数组中元素最大值
     * 
     * @param arrNum int[]
     * @return int
     */
    public static int getMax(int[] arrNum) {
        int max = arrNum[0];
        for (int i = 1; i < arrNum.length; i++) {
            if (max < arrNum[i]) {
                max = arrNum[i];
            }
        }
        return max;
    }

    /**
     * 求数组中元素最小值
     * 
     * @param arrNum int[]
     * @return int
     */
    public static int getMin(int[] arrNum) {
        int min = arrNum[0];
        for (int i = 1; i < arrNum.length; i++) {
            if (min > arrNum[i]) {
                min = arrNum[i];
            }
        }
        return min;
    }

    /**
     * 冒泡排序(升序排列)
     * @param arr int[] 
     * @return void
     */
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j] > arr[j+1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    /**
     * 冒泡排序(降序排列)
     * @param arr int[] 
     * @return void
     */
    public static void bubbleSort2(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j] < arr[j+1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    /**
     * 逆序打印数组元素
     * @param arr
     * @return void
     */
    public static void reversePrint(int[] arr) {
        for (int i = arr.length-1; i >= 0; i--) {
            System.out.print(arr[i]+" ");
        }
    }


    public static void main(String[] args) {
        int[] arr = {10,20,5,64,32};
        reversePrint(arr);

    }

}

8.java参数传递：
（1）java中的参数传递全是值传递；
（2）基本类型：形式参数的改变对实际参数没影响；
（3）引用类型：形式参数的改变直接影响实际参数；

雅静8

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
JAVASE基础回顾总结（二）

JAVASE基础回顾总结（二）1.运算符：（1）面试题：s+=1 不等价于：s=s+1;而是等价于s=（s的数据类型）s+1; （2）面试题：&和&&（|和||）区别：结果相同，但是&&（||）是短路运算；2.选择结构if和switch如何选择？（1）if的使用场景：针对结果是boolean类型的判断；因为switch（byte、short、int、char、String、枚举）只能判断
复制链接

扫一扫