Java 个人总结 3

位运算符

位运算效率极高。

A = 0011 1100
B = 0000 1101
-————————–
A&B = 0000 1100 且
A|B = 0011 1101 或
A^B = 0011 0001 异或
~B = 1111 0010 取反

Q：对于计算机来说，更快地计算2*8=?
A：位运算，2 << 3 = 16

包机制

为了更好地组织类 Java提供了包机制，用于区别类名的命名空间。
一般利用公司域名倒置作为包名：com.uwupu.blog
在类里需要添加 package com.uwupu.blog

JavaDoc 文档注释

/**
 * 类注释
 * @author uwupu 作者
 * @version 1.0  版本
 * @since 1.8    JDK版本
 */
public class UDoc {
    String name;  // 类变量

    /**
     * 方法注释
     * @author uwupu 作者
     * @param name  参数
     * @return       返回值
     * @throws Exception 抛出
     */
    public String uTest(String name) throws Exception{
        return name;
    }
}

生成文档

在类所在文件夹中打开终端，执行以下命令，可以生成类的文档。
javadoc -encoding UTF-8 -charset UTF-8 类名.java

增强的for循环

.JDK 5 引入用于数组和集合的循环

public class ForDemo {
    public static void main(String[] args) {
        int[] ns = {10,20,30,40,50};
        for ( int i : ns){
            System.out.println(i);
        }
        /*
        结果：
            10
            20
            30
            40
            50
         */
    }
}

方法重载

规则：

方法名必须相同；
参数必须不同；
方法返回类型可以相同也可不同；
仅仅返回类型不同不足以成为方法的重载；

命令行传参

public static void main(String[] args)中的args即为参数。

public class Args {
    public static void main(String[] args) {
        for(String i : args){
            System.out.println(i);
        }
    }
}

可变参数

.Java 1.5开始，可以通过“…”来创建可变参数

public class Demox3 {

    public static void main(String[] args) {
        Demox3.printMax(123,123,234);
    }
    public static void printMax(double... numbers){
        for(double i : numbers){
            System.out.println(i);
        }
        /*
        结果：
        123.0
        123.0
        234.0
         */
    }
}

注意

若有多个参数，将可变参数放在最后一个；
一个方法只能有一个可变参数。

数组创建

在Java中，一般用DataType[] arrayRefVar;方式声明数组变量，一般不用DataType arrayRefVar[];

创建数组用new DataType[];
即

public class Array {
    public static void main(String[] args) {
        int[] nums; //定义
        nums = new int[10]; //创建并赋值
        int[] nums2 = {1,2,3}; //静态初始化
    }
}

内存分析

堆：

存放new的对象和数组;
可以被所有的线程共享，不会存放别的对象引用。

栈：

存放基本变量类型(会包含这个基本类型的具体数值);
引用对象的变量(会存放这个引用在堆里面的具体地址)。

方法区：

可以被所有的线程共享；
包含了所有的class和static变量。

内存分布

其他

数组下标越界异常：ArrayIndexOutOfBoundsException

数组

数组是引用类型。一旦分配，会被隐式地初始化。
长度是确定的，一旦被创建，不可改变；
数组中的元素可以是任何数据类型，包括基本类型和引用类型；
数组对象本身在堆中。

Arrays类

数组工具类：java.util.Arrays

Arrays.toString(数组)方法可以将数组转换为字符串；
Arrays.sort(数组) 将数组排序。
Arrays.fill(数组，值) 将数组填充为指定值。
Arrays.fill(数组，开始，结束，值) 将从开始到结束的位置设置为指定值。

冒泡排序

时间复杂度：O(n^2)

public class BubbleSort {

    public static void main(String[] args) {
        int[] array = {1,5,2,3,2,1,5};
        array = UBubbleSort(array);
        System.out.println(Arrays.toString(array));
    }

    public static int[] UBubbleSort(int []array){
        int len = array.length;
        int temp;
        for(int i = 0 ; i < len-1 ; i++){
            for(int j = len-1 ; j > i ;j--){
                if(array[j] < array[j-1]){
                    temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                }
            }
        }
        return array;

    }
}

优化

public class BubbleSort {

    public static void main(String[] args) {
        int[] array = {1,5,2,3,2,1,5};
        array = UBubbleSort(array);
        System.out.println(Arrays.toString(array));
    }

    public static int[] UBubbleSort(int []array){
        int len = array.length;
        int temp;
        for(int i = 0 ; i < len-1 ; i++){
            boolean flag = false; // 通过flag表示位减少没有意义的比较

            //内层循环
            for(int j = len-1 ; j > i ;j--){
                if(array[j] < array[j-1]){
                    temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                    flag = true; // 当前有交换项
                }
            }

            if(!flag){
                //若没有交换项，表示剩下已排好序
                break;
            }
        }
        return array;

    }
}

稀疏数组

.当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组

一个5x5的二维数组

.	.	.
0	0	6
3	5	0
0	4	0
0	0	0
0	0	0

稀疏数组表示

rows	cols	value
0	4	6
1	1	3
1	2	5
2	2	4