JAVA萌新学习day8

JAVA萌新学习day8

一.关于内存使用的一些说明

public class MemoryDemo {
    public static void main(String[] args) {
        System.out.println("关于内存使用的一些说明:");

        /*
        1.虚拟机把自己管理的内存分成三大块:1.Stack(栈) 2.Heap(堆) 3.Metaspace.
        2.方法内声明的局部变量(基本类型)都保存在Stack中.
        3.凡用new关键字创建的对象，都保存在Heap中(字符串除外).
        4.使用new关键字创建的变量类型叫引用类型(字符串也是引用类型，数组也是).
        5.引用类型的变量中保存的知识对象在内存中的地址.
        6.引用类型的变量互相赋值，实际只是把他们只想对象的内存拷贝保存.
        7.基本类型用 == 判断是否相等时，是指两个变量的值是否相等.
        8.引用类型用 == 判断是否相等时，是指两个变量指向对象的内存地址是否相等.
        */

        int numberA = 10;
        int numberB = 10;
        int numberC = numberA;

        System.out.println(numberA == numberB);
        System.out.println(numberC == numberB);

        int[] arrayA = new int[5];
        int[] arrayB = new int[5];
        int[] arrayC = arrayA;

        System.out.println(arrayA == arrayB);
        System.out.println(arrayC == arrayA);

        System.out.println(arrayA);


    }

二.二维数组的基本使用

import java.util.Random;
import java.util.Arrays;

public class DoubleArray {
    public static void main(String[] args) {
        System.out.println("二维数组的基本使用");


        //动态声明数组
        int[] array = new int[10]; //线性,一维数组.

        //0 1 2 3 4 ... 9  下标或者叫索引
        //1 2 3 4 5 ... 15 值
        array[0] = 10;//通过索引访问指定下标所在的元素

        //[]说明要声明的变量是一个数组类型
        //数组保存的元素类型是什么???
        //[]前面的类型是指数组中保存的元素的类型,这里就是int.
        //我声明了一个可以保存整型变量的数组.
        int[] array2 = new int[5];
        //如果int[] 和 符号Du 等同
        //int[] array2 和 Du array2 相同
        //Du[] array3 和 int[][] array3 相同
        //声明一个数组，它里面的每一个元素还是数组类型

        /*
        1 2 3 4 5 6 7 8 9 10
        11 12 13
        21 22 23
        */
        int[][] array3 = new int [5][3];
        int[][] array4 = {{1,2},{3,4,5},{6,7,8,9,10}};
        for(int i = 0; i < array.length ; i++){
            System.out.println(array[i]);
        }

        for (int i = 0; i < array3.length; i++) {

            int[] temp = array3[i];
            for (int j = 0; j < temp.length; j++) {
                //temp[j] = array3[i][j]

            }
        }




        Random random = new Random();
        //定义一个二维数组,用来保存我们班所有同学的选修课的成绩
        int[][] scores = new int[15][3];
        for (int i = 0; i < scores.length; i++) {

            // int[] temp = scores[j];

            for (int j = 0; j < scores[i].length; j++) {
                //产生90-100的成绩(不包括 100)
                scores[i][j] = random.nextInt(10) + 90;

            }
            //将数组内容转成字符
            String str = Arrays.toString(scores[i]);
            //打印输出
            System.out.println(str);
        }

        //某某同学,三门成绩分别是 99.90.95 获得第几名,平均成绩是
    }

}

三.数组的排序以及查找方法

import java.util.Arrays;

public class SortArray {
    public static void main(String[] args) {
        System.out.println("数组的排序");

        int[] a = {100,7,34,35,3,55,78};

        /*
        {100,7,34,35,3,55,78}
        {7,100,34,35,3,55,78}
        {7,34,100,35,3,55,78}
        */



        /*
        冒号排序
        外层循环控制比较的轮次,内层循环控制每轮比较的次数.
        每次内循环遍历一次,就确定一个最大值或最小值.
        所以导致下一轮比较的时候,比较次数减一
        */

        for (int i = 0; i < a.length-1; i++) {

            for (int j = 0; j < a.length-1-i; j++) {
                //j=0,用j=0的元素和j=1的元素比较,j=0大于j=1
                //j=1,用j=2的元素和j=1的元素比较,j=1大于j=2

                if(a[j] > a[j + 1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
                print(a,i,j);//输出每一轮每一次比较后数组的目前内容.

            }
        }

        System.out.println("-----------------------------------------------------------------");

        /*
        选择排序:
        思路是每一轮比较的时候,都选择一个固定位置的值和它后面的每一个值比较.
        */

        int[] b = {10,7,38,35,3,55,78};
        for (int i = 0; i < b.length-1; i++) {
            for (int j = i+1; j < b.length; j++) {
                if(b[i] > b[j]){
                    int temp = b[i];
                    b[i] = b[j];
                    b[j] = temp;
                }
                print(b,i,j);
            }

        }

        System.out.println("-----------------------------------------------------------------");

        int value = binarySearch(a,34);
        System.out.println("查找到的下标为:" + value);

        System.out.println("-----------------------------------------------------------------");


    }
    //打印数组的所有内容
    public static void print(int[] array,int iIndex,int jIndex){
        String str = Arrays.toString(array);
        System.out.println(iIndex + ":" + jIndex + "->" + str);

    }

    //从指定数中查找指定的元素,如果找到,返回在原数组中的位置(下标),找不到返回-1.
    public static int searchArray(int[] array, int value){
        //遍历数组,即访问数中的每一个元素.
        for (int i = 0; i < array.length; i++) {
            //用数组中的元素和要查找的数比较,如果相等,返回下标.
            if(array[i] == value){
                return i;
            }
        }
        //找不到返回-1
        return -1;
    }

    /*
    0  -  length  length/2
    */



    //二分法查找,前提是要查找的原数组是有序的,本程序中是升序
    public static int binarySearch(int[] array ,int value) {
        //确定起始查找范围
        int left = 0;
        int right = array.length-1;

        while(left <= right){
            int middle = (left + right)/2;
            //中间值比查找的范围大,说明要查找的值在左半部分.
            if(array[middle] > value){
                right = middle - 1;
            }
            //中间值,比要查找的值小,说明要查找的值在大的半部分.
            else if(array[middle] < value){
                left = middle + 1 ;
            }
            else{
                return middle;
            }
        }
        return -1;
    }
}