Java基础（1）

写在前面，因为已经有了其他语言的一部分基础在这里只记录Java语言在IDE中与其它语言的不同之处，仅供自己学习

Chapter2

从控制台读取输入

• 使用Scanner类来从控制点输入，Java使用System.out来表示标准输出设备，用System.in来表示标准输入设备，为了获得控制台输入，可以使用Scanner类创建一个对象，以读取来自System.in的输入

Scanner input = new Scanner(System.in);

• 声明input是一个Scanner类型的变量，创建了一个Scanner对象，并且将它的引用值赋值给变量input，对象可以调用其方法，可以调用nextDouble()方法来读取一个double值

public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("Enter a number for radius:");
        //int radius = input.nextInt();
        double radius = input.nextDouble();
        double area = radius * radius * 3.14159;
        System.out.println("The area for the circle of radius " + radius + " is " + area);
    }

• 常见非法代码

        int i = j = k = 2;//不支持，是非法的代码

• 修改为

        int i,j,k;
        i = j = k = 2;

明确导入和通配符导入

• 明确导入：在import语句中指定单个的类
• 通配符导入：通过使用星号作为通配符，导入一个包中所有的类

import java.util.*;

声明常量

• 语法结构

		final datatype CONSTANTNAME = value;
        final double PI = 3.14159;

Chapter3

读取二进制、八进制、十六进制

• 二进制：前加0b（零b）
• 八进制：前加0（0）
• 十六进制：前加（0X）
  两个浮点数值的相等测试

        double x = 1.0 - 0.1 - 0.1 - 0.1 - 0.1;
        System.out.println(x == 0.5);
        //false

产生随机数

        int number1 = (int)(Math.random() * 10);
        int number2 = (int)(Math.random() * 10);

Switch语句

switch(switch表达式){
	case 值1:语句组1;
		break;
	case 值2:语句组2;
		break;
	...
	default:默认情况下执行的语句组
}

Chapter4

Math类方法分为三类：三角函数方法、指数函数方法、服务方法。服务方法包括取整、求最小值、求最大值、求绝对值和随机方法。Math类提供了两个有用的double型常量，PI（Π）和E（自然对数的底），可以用Math.PI和Math.E来使用这两个常量

三角函数方法

• sin(radians)：返回以弧度为单位的角度的三角正弦函数值
• cos(radians)：返回以弧度为单位的角度的三角余弦函数值
• tan(radians)：返回以弧度为单位的角度的三角正切函数值
• toRadians(degree)：将以度为单位的角度值转换为以弧度表示
• toDegree(radians)：将以弧度为单位的角度值转换为以度表示
• asin(a)：返回以弧度为单位的角度的反三角正弦函数值
• acos(a)：返回以弧度为单位的角度的反三角余弦函数值
• atan(a)：返回以弧度为单位的角度的反三角正切函数值

        System.out.println(Math.toDegrees(Math.PI / 2));
        System.out.println(Math.toRadians(30));
        System.out.println(Math.sin(0));
        System.out.println(Math.sin(Math.toRadians(-270)));
        System.out.println(Math.sin(Math.PI / 6));
        System.out.println(Math.cos(0));
        System.out.println(Math.asin(0.5));
        System.out.println(Math.acos(0.5));
        System.out.println(Math.atan(1));

指数函数方法

• exp(x)：返回e的x次方
• log(x)：返回x的自然对数
• log10(x)：返回x的以10为底的对数
• pow(a,b)：返回a的b次方
• sqrt(x)：对于x大于等于0的数字，返回x的平方根

        System.out.println(Math.exp(3.5));
        System.out.println(Math.log(3.5));
        System.out.println(Math.log10(3.5));
        System.out.println(Math.pow(2,3));
        System.out.println(Math.sqrt(4));

取整方法

• ceil(x)：x向上取整为它最接近的整数，该整数作为一个双精度值返回
• floor(x)：x向下取整为它最接近的整数，该整数作为一个双精度值返回
• rint(x)：x取整为它最接近的整数，如果x与两个整数的距离相等，偶数的整数作为一个双精度值返回
• round(x)：如果x是单精度数，返回(int)Math.floor(x+0.5)，如果x是双精度数，返回(long)Math.floor(x+0.5)
  min、max、abs方法
  random方法

a + Math.random() * b //返回a~a+b之间的一个随机数，不包括a+b

char和string的区别
String类型

• 是一个引用类型
• length()：返回字符串中的字符数
• charAt(index)：返回字符串中指定位置的字符
• concat(sl)：将本字符串和字符串sl连接，返回一个新字符串
• toUpperCase()：返回一个新字符串，其中所有的字母大写
• toLowerCase()：返回一个新字符串，其中所有的字母小写
• trim()：返回一个新字符串，去掉了两边的空白字符（’ ‘、’\t’、‘\f’、‘\t’、’\n’称为空白字符）
• +用于连接数字和字符串，先将数字转换成字符串，然后再进行连接，至少要有一个操作数必须为字符串
• +=也可以用于字符串连接

        String string = "welcome to java!";
        string += " and java is fun";
        System.out.println(string);

next()方法

• next()方法读取以空白字符结束的字符串(即’ ‘、’\t’、’\f’、’\r’或’\n’)，可以用nextLine()方法读取一整行文本
• 将使用方法next()、nextByte()、nextShort()、nextInt()、nextLong()、nextFloat()、nextDouble()的输入称为基于标记的输入

        Scanner input = new Scanner(System.in);
        String string = input.nextLine();
        char ch = string.charAt(0);
        System.out.println(ch);

字符串比较

• equals(sl)：如果该字符串等于字符串sl，返回true
• equalsIgnoreCase(sl)：如果该字符串等于字符串sl，返回true;不区分大小写
• compareTo(sl)：返回一个大于0、等于0、小于0的整数，表明该字符串是否大于、等于或者小于sl

源码解读：

    public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

• compareToIgnoreCase(sl)：和compareTo一样，除了比较是不区分大小写的外
• startsWith(prefix)：如果字符串以特定的前缀开始，返回true
• endWith(suffix)：如果字符串以特定的后缀结束，返回true
• contains(sl)：如果sl是该字符串的子字符串，返回true
• 注：不能使用==判断两个字符串变量的内容是否相同，==只能检测是否指向同一个对象，不会检测内容
  获得子字符串
• substring(beginIndex)：返回该字符串的子串，从指定位置beginIndex的字符开始到字符串的结尾
• substring(beginIndex,endIndex)：返回该字符串的子串，从指定位置beginIndex的字符开始到下标endIndex-1的字符

        String string1 = "welcome to java";
        String string2 = string1.substring(0,10);
        System.out.println(string2);

获取字符串中的字符或者子串

• indexOf(ch)：返回字符串中出现的第一个ch的下标，如果没有匹配的，返回-1
• indexOf(ch,fromIndex)：返回字符串中fromIndex之后出现的第一个ch的下标，如果没有匹配的，返回-1
• indexOf(s)：返回字符串出现的第一个字符串s的下标，如果没有匹配的，返回-1
• indexOf(s,fromIndex)：返回字符串中fromIndex之后出现的第一个字符串s的下标，如果没有匹配的，返回-1
• lastIndexOf(ch)：返回字符串中出现的最后一个ch的下标，如果没有匹配的，返回-1
• lastIndexOf(ch,fromIndex)：返回字符串中fromIndex之前出现的最后一个ch的下标，如果没有匹配的，返回-1
• lastIndexOf(s)：返回字符串中出现的最后一个字符串s的下标，如果没有匹配的，返回-1
• lastIndexOf(s,fromIndex)：返回字符串中fromIndex之前出现的最后一个字符串s的下标，如果没有匹配的，返回-1
  字符串和数字之间的转换
• 可以将数值型字符串转换为数值，要将字符串转换为int值，使用Integer.parseInt方法
• 将字符串转换为double值，使用Double.parseDouble方法

        String string3 = "123";
        int intValue = Integer.parseInt(string3);
        System.out.println(intValue);
        String string4 = "123.21312";
        double doubleValue = Double.parseDouble(string4);
        System.out.println(string4);

• 可以将数值转换为字符串，只需要简单使用字符串的连接操作符

String s = number + "";

格式化控制台输出

System.out.printf

• 不要比较两个浮点数是否相等来进行循环控制，因为浮点值都是近似数

Chapter6

• 定义方法

修饰符 返回值类型 方法名(参数列表){
//方法体
}

• 调用栈：每当调用一个方法时，系统会创建一个活动记录，用于保存方法中的参数和变量，活动记录置于一个内存区域
  void方法与返回值方法
• void方法不返回值，但是可以有return;来返回调用者
• 对void方法的调用必须是一条语句
  按值传参
• 参数顺序匹配：参数序列和数量相匹配，参数类型要兼容，实参在按值传递过程中保持不变
  重载方法
• 在一个类中有两个方法，他们具有相同的名字，但有不同的参数列表，Java编译器根据方法签名决定先使用哪个方法
• 编译器无法判断哪个方法是最精确的匹配，产生歧义调用
• 匹配规则为：直接匹配类型>自动类型转换>自动装箱>匹配接口实现>匹配父类>匹配变长参数

变量的作用域

• 变量的作用域是指变量可以在程序中被引用的范围
• 在方法中定义的变量叫局部变量，局部变量的作用域是从变量声明的地方开始、直到包含该变量的块结束为止，局部变量都必须在使用之前进行声明和赋值
• 方法的实现细节封装在方法内，对使用该方法的用户来说是隐藏的，就叫做封装
• 方法抽象：将方法的使用和它的实现分离来实现

Chapter7

创建数组

• 声明一个数组变量时并不给数组分配任何内存空间，只是创建一个对数组的引用的存储位置
• 存储的是指向数组的引用

//声明一个数组变量、创建数组、将数组引用赋值给变量
elementType[] arrayRefVar = new elementType[arraySize];

• 数组初始化简写方式

elementType[] arrayRefVar = {value0,value1,value2};
double[] mylist = {1.1,2.2,3.3};

foreach循环

• 不使用下标变量就可以顺序遍历整个数组

        for (double e : mychar){
            System.out.println(e);
        }

for(elementType element : arrayRefVar){
	//Process the element
	}

复制数组

• 使用循环语句逐个地复制数组的元素
• 使用System类种地静态方法arraycopy：arraycopy方法没有给目标数组分配内存空间，复制前必须创建目标数组以及分配给它的内存空间，复制完成后，具有相同的内容，但占有独立的内存空间
• 使用clone方法复制数组

        double[] mylist = new double[3];
        for (int i = 0;i < mylist.length;i++){
            mylist[i] = i;
        }
        double[] mylist1 = new double[3];
        System.arraycopy(mylist, 0, mylist1, 0, 3);
        for (int i = 0;i < mylist1.length;i++){
            System.out.println(mylist1[i]);
        }

注list2 = list1这样是将list1的引用值复制给了list2,list2原先所引用的数组不能再引用，它就变成了垃圾,会被java虚拟机自动收回(垃圾回收)

• 在java中可以使用赋值语句复制基本数据类型的变量，但不能复制数组。将一个数组变量赋值给另一个数组变量，实际上是将一个数组的引用复制给另一个变量，使两个变量都指向相同的内存地址
  将数组传递方法
• 当将一个数组传递给方法时，数组的引用被传给方法
• java使用按值传递的方式将实参传递给方法
• 对于基本数据类型参数，传递的是实参的值
• 对于数组类型参数，参数值是数组的引用，给方法传递的是这个引用，方法中的数组和传递的数组是一样的，如果改变方法中的数组，将会看到方法外的数组也改变了

public class Test {
    public static void main(String[] args) {
        int x= 3;
        int[] y = {3};
        fun(x,y);
        System.out.println(x);
        System.out.println(y[0]);
    }
    public static void fun(int x,int[] y){
        x = 1;
        y[0] = 2;
    }

方法返回数组

    public static int[] fun(int x,int[] y){
        x = 1;
        y[0] = 2;
        int[] result = {1,2,3,4,5};
        return result;
    }

可变长参数列表

• 具有同样类型的数目可变的参数可以传递给方法，并将作为数组对待

typeName... parameterName(类型名... 参数名)

• 在方法声明中，指定类型后紧跟着省略号(…),只能给方法中指定一个可变长参数，同时该参数必须是最后一个参数，任何常规参数必须在它之前

    public static void main(String[] args) {
        printMax(34,3,3,2,56.6);
        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(result);
    }

数组的查找

• 如果一个数组排好序了，对于查找数组中的一个元素，二分查找比线性查找更加高效
• 线性查找法：将要查找的关键字与数组中的每一个元素进行比较。数组中的元素可以按任意排序。
• 二分查找法：使用二分查找法的前提条件是数组中的元素必须排好序。假设数组已按升序排列。二分查找法首先将关键字与数组的中间元素进行比较
• 如果关键字小于中间元素，只需要在数组的前一半元素中继续查找关键字
• 如果关键字和中间元素相等，则匹配成功，查找结束
• 如果关键字大于中间元素，只需要在数组的后一半元素中继续查找关键字
• 将关键字key和下标low为0、下标high为list.length-1的列表的中间元素进行比较，如果key<list[mid]，就将下标high设置为mid-1，如果key==list[mid]则匹配成功并返回mid，如果key>list[mid]，就将下标low设置为mid+1

//二分查找
    public static int binarySearch(int[] list,int key){
        int low = 0;
        int high = list.length - 1;
        while (high >= low){
            int mid = (high + low) / 2;
            if (key < list[mid])
                high = mid - 1;
            else if (key == list[mid])
                return mid;
            else low = mid + 1;
        }
        return -low - 1;
    }

数组的排序

• 选择排序法：先找到数列中最小的数，然后将它和第一个元素交换，接下来在剩下的数种找到最小数，将它与第二个元素交换，直到数列种仅剩一个数为止

    public static void selectionSort(double[] list){
        for (int i = 0;i < list.length;i++){
            double currentMin = list[i];
            int currentMinIndex = i;
            for (int j = i + 1; j < list.length; j++) {
                if (currentMin > list[j]) {
                    currentMin = list[j];
                    currentMinIndex = j;
                }
            }
            //swap list[i] when list[i] is not minumum
            if (currentMinIndex != i) {
                list[currentMinIndex] = list[i];
                list[i] = currentMin;
            }
        }
    }

Arrays类

• 包含了排序和查找方法
• sort和parallelSort方法对整个数组或部分数组进行排序
• binarySearch：二分查找法，数组必须题前按升序排好，如果数组中不存在关键字，方法返回- low - 1

    public static void main(String[] args) {
        double[] numbers = {6.0,4.4,1.9,2.9,3.4,3.5};
        Arrays.sort(numbers);
        Arrays.parallelSort(numbers);
        char[] chars = {'a','A','4','F','D','P'};
        Arrays.sort(chars);
        Arrays.parallelSort(chars);
        int[] list = {2,4,7,10,11,45,50,59,60,66,69,70,79};
        System.out.println(Arrays.binarySearch(list,11));
        System.out.println(Arrays.binarySearch(list,12));
    }

• equals方法检测两个数组是否严格相等，如果它们对应的两个数组严格相等，返回true，否则返回false

    public static void main(String[] args) {
        int[] list1 = {2,4,7,10};
        int[] list2 = {2,4,7,10};
        int[] list3 = {4,2,7,10};
        System.out.println(Arrays.equals(list1,list2));
        System.out.println(Arrays.equals(list1,list3));
    }

• fill方法填充整个数组或部分数组
• toString方法来返回一个字符串，字符串代表数组中的所有元素，是一个显示数组中所有元素的快捷和简便的方法

    public static void main(String[] args) {
        int[] list1 = {2,4,7,10};
        int[] list2 = {2,4,7,10};
        int[] list3 = {4,2,7,10};
        System.out.println(Arrays.equals(list1,list2));
        System.out.println(Arrays.equals(list1,list3));
        Arrays.fill(list1,5);
        Arrays.fill(list2,1,4,8);
        System.out.println(list1.length);
        System.out.println(list2.length);
        System.out.println(Arrays.toString(list2));
    }
//
true
false
4
4
[5, 5, 5, 5]
[2, 8, 8, 8]

命令行参数

• main方法的声明有些特殊，具有String[]类型参数args，main方法就和普通方法一样，可以从命令行传递参数