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 文档注释
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public class UDoc {
String name;
public String uTest(String name) throws Exception{
return name;
}
}
|
生成文档
在类所在文件夹中打开终端，执行以下命令，可以生成类的文档。
javadoc -encoding UTF-8 -charset UTF-8 类名.java
增强的for循环
.JDK 5 引入用于数组和集合的循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public class ForDemo {
public static void main(String[] args) {
int[] ns = {10,20,30,40,50};
for ( int i : ns){
System.out.println(i);
}
}
}
|
方法重载
规则：
- 方法名必须相同；
- 参数必须不同；
- 方法返回类型可以相同也可不同；
- 仅仅返回类型不同不足以成为方法的重载；
命令行传参
public static void main(String[] args)中的args即为参数。
1
2
3
4
5
6
7
8
| public class Args {
public static void main(String[] args) {
for(String i : args){
System.out.println(i);
}
}
}
|
可变参数
.Java 1.5开始，可以通过“…”来创建可变参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| 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);
}
}
}
|
注意
- 若有多个参数，将可变参数放在最后一个；
- 一个方法只能有一个可变参数。
数组创建
在Java中，一般用DataType[] arrayRefVar;方式声明数组变量，一般不用DataType arrayRefVar[];
创建数组用new DataType[];
即
1
2
3
4
5
6
7
| public class Array {
public static void main(String[] args) {
int[] nums;
nums = new int[10];
int[] nums2 = {1,2,3};
}
}
|
内存分析
堆：
- 存放new的对象和数组;
- 可以被所有的线程共享，不会存放别的对象引用。
![image]()
栈：
- 存放基本变量类型(会包含这个基本类型的具体数值);
- 引用对象的变量(会存放这个引用在堆里面的具体地址)。
方法区：
- 可以被所有的线程共享；
- 包含了所有的class和static变量。
![image]()
其他
数组下标越界异常：ArrayIndexOutOfBoundsException
数组
- 数组是引用类型。一旦分配，会被隐式地初始化。
- 长度是确定的，一旦被创建，不可改变；
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型；
- 数组对象本身在堆中。
Arrays类
数组工具类：java.util.Arrays
Arrays.toString(数组)方法可以将数组转换为字符串；
Arrays.sort(数组) 将数组排序。
Arrays.fill(数组，值) 将数组填充为指定值。
Arrays.fill(数组，开始，结束，值) 将从开始到结束的位置设置为指定值。
冒泡排序
时间复杂度：O(n^2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| 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;
}
}
|
优化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| 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;
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 |
0 |
0 |
6 |
| 0 |
3 |
5 |
0 |
0 |
| 0 |
0 |
4 |
0 |
0 |
| 0 |
0 |
0 |
0 |
0 |
| 0 |
0 |
0 |
0 |
0 |
稀疏数组表示
| rows |
cols |
value |
| 0 |
4 |
6 |
| 1 |
1 |
3 |
| 1 |
2 |
5 |
| 2 |
2 |
4 |
