javase 笔记整理（第五章）

第五章：

1. Math类常见方法：

PI:圆周率，属性；

E:自然常数；

abs(num):返回绝对值；

cbrt(a):开立方根；

ceil(a):向上去找取整；

floor(a):向下去找取整；

round(a):四舍五入取整；

max(a,b):返回两者最大值；

min(a,b):返回最小值；

*****pow(a,b):返回a的b次方(double类型)；

*****random():返回0到1之间的一个随机数[0,1)；

随机数：

计算机中随机数都是伪随机数；

1:Math.random;

2:import java.util.Random;

       Random r = new Random(seed);

r.nextInt(round);

Scanner类：

next();通过空格获取数据（单词）

nextInt();

nextDouble();

nextFloat();

nextLine();

……

Java常见的内置对象：

Math:(final修饰)

Random;

Scanner;(final修饰)

Java中的常量和常量定义：

用final修饰，不可更改；常量；

字符串对象：

Java.lang.String；

字符串：字符连在了一起，形成了字符串。人的肉眼可见。

在java中，一般表现为””,引号的内部内容就是字符串；可为空；

在Java中，字符串为引用数据类型；

在Java中为常量，不可更改；

定义字符串；

String s = “this is a book!”;//定义一个字符串

new String();

String s = new String;//等价于String s = “”;

常见的字符串方法：

charAt(i):获取对应索引号的字符；

Length():获取字符串长度；

PointAt(i):返回对应索引值的字符的Unicode码；

concat(str):连接字符串，等同于+；拼接字符串；

contions(str)：判断是否包含某个字符串；返回值为Boolean类型；

copyValueOf(char[]);将字符拼接成字符串；

endsWith();判断是否以某字符结尾；返回boolean值；

startsWith()：判断是否以某字符开头；

equals();判断字符串是否相等；

equalsIgnoreCare();忽略大小写判断字符串是否相等；

getByte();将字符串转变为字节数据；

IndexOf();获取某个符号或者字符串的索引值；（从前往后找）

lastIndexOf();从后往前找对应字符串索引值；

isEmpty();判断字符串是否为空；

replace(,oldstr,newstr)：新字符替换旧字符；

join(“字符”，数组)：将数组以特定字符为分隔拼接成字符串；

spilt(“字符”)；将字符串以特定字符分割开；

substring(index):从开始位置截取到末尾；

Substring(start,end):左闭右开截取字符串；

toCharArry();

toLowerCase();

toUpperCase();

trim();清除两侧空格；

valueOf()；拼接字符串；

字符串不要使用等于符号判断是否相等；等号比较的是地址值；

因为字符串创建方式有多种，不同方式创建地址可能不一样；

数组：

什么是数组？

容器（collection）：一般是一种数据结构；是用来解决多个数据保存和运算的。

线性结构：数组，队列，栈，队列，链表。

非线性结构：哈希表，树形结构，图；

数组是一种长度固定，内存连续的线性结构。

用来解决大量数据的存储问题；

特点：

1：大小固定；

2：连续内存地址；

3：存储数据类型固定；

4：数组保存在堆内存中；因此数组本质是对象；

5：数组变量存的是数组首元素的地址；

6：创建数组时必须定义长度；

定义方式：
第一种：

数据类型[] 变量名称 = new 数据类型[size];

第二种：

数据类型[] 变量名称 = new 数据类型[]{值1，值2，值3，值4……}；

第三种：

数据类型[] 变量名称 = {值1，值2，值3……}；

数组的长度（元素个数）：

数组对象.length；（length属性）

访问数组元素（element）：

通过下标访问，注意：在编程中，大部分下标都是从0开始的。

数组对象[下标];访问对应下标的数组元素；

修改数组元素：

数组对象[下标] = 新值；

遍历数组：

1：for(int i = 0 ; i < arr.length;i++){

   System.out.println(arr[i]);

}

2：foreach//加强循环；

for (数据类型 临时变量 ： 可迭代变量){

     System.out.println(临时变量)；

}

练习：生成一个长度为10的数组，找到其中最大值，最小值，平均值并输出；

算法：

      排序：

查找：

排序：

     将无序的数据按照有特定规则拍成有序数据（升序，降序）；

 常见的排序算法有十几种。

冒泡：O(n^2)    稳定

选择：O(n^2)    不稳定

插入：

值传递和引用传递的区别：

值传递传递的是变量值；在函数中改变并不影响主函数中变量值；（使用函数时开辟临时空间存储变量，函数结束后释放空间，变量也随之消失）（普通变量）

引用传递传递的是地址空间，函数中改变变量值也会影响主函数中变量值；（使用函数时开辟临时空间存储地址空间，函数中改变变量值时会直接根据地址值索引到堆内存中直接对原变量进行操作，函数结束空间释放，但变量值也已经改变）；（数组）

查找算法：

二分查找

代码演示：（三种排序及二分查找）

package com.test;

import java.util.Scanner;

public class paixu {
    public static void main(String[] args) {
        int[] a = {1, 324, 56, 78, 9, 998, 97, 33, 22};
        System.out.println("排序前数组为：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "   ");
        }
        System.out.println();
        sort1(a);
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查找的数字：");
        int b = sc.nextInt();
        int middle = search(a,b);
        if(middle != -1)
        System.out.println("该数字位于数组的第"+(middle+1)+"个位置");
        else System.out.println("该数组没有该数字！！！");
//         System.out.println();
//         sort2(a);
//        System.out.println();
//        sort3(a);
    }

    //冒泡排序；
    public static void sort1(int[] a) {
        for (int i = 0; i < a.length; i++) {
            for (int k = 1; k < a.length - i; k++) {
                if (a[k] < a[k - 1]) {
//                          int temp = a[k-1];
//                          a[k-1] = a[k];
//                          a[k] = temp;
                    swap(a, k, k - 1);
                }
            }
        }
        System.out.println("冒泡排序后：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "   ");
        }
    }


    //选择排序；
    public static void sort2(int[] a) {
        int temp;
        for (int i = 0; i < a.length; i++) {
            for (int j = i + 1; j < a.length; j++) {
                if (a[i] > a[j]) {
//                    temp = a[j];
//                    a[j] = a[i];
//                    a[i] = temp;
                    swap(a, i, j);
                }
            }

        }
        System.out.println("选择排序后：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "   ");
        }
    }

    //插入排序；
    public static void sort3(int a[]) {
        for (int i = 1; i < a.length; i++) {
            int j = i;
            while (j >= 1) {
                if (a[j] < a[j - 1]) {
//                    int temp = a[j];
//                    a[j] = a[j - 1];
//                    a[j - 1] = temp;
                    swap(a, j, j - 1);
                }
                j--;
            }
        }
        System.out.println("选择排序后：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "   ");
        }
    }

    private static void swap(int[] arry, int a, int b) { //引用传递，否则无法交换数值
        int temp = arry[a];
        arry[a] = arry[b];
        arry[b] = temp;
    }

//二分查找

    public static int search(int[] a, int b) {
        int start = 0;
        int end = a.length - 1;
        for (int i = 0; i < a.length - 1; i++) {
            int middle = (start + end) / 2;
            if (a[middle] > b) {
                end = middle - 1;
            } else if (a[middle] < b) {
                start = middle + 1;
            } else {
                return middle;
            }
        }
        return -1;
    }
}