文章目录
1. eclipse 操作
官方下载eclipse.
修改字符集utf8,设置字体格式等。
alt + / 可以自动填充代码。 像下面的都可以直接操作。
-
main => 对应main函数。
-
syso => 对应System.out.println();
导入已有的项目工程
导入的项目工程,可能会出现乱码情况(字符集问题)。正常情况下,windows系统默认是GBK,这里转为了utf8肯定乱码。因此,我们可以通过notepad++,给他转为utf8格式再导入。
隐藏关闭项目
我们在ctrl+鼠标左键,查看源码,可能需要先关联源码(attach source),配置如下:
设置注释内容,例如:作者,版本,创建时间等等。
2. 数组 定义和概述
数组定义:
数组注意事项:
- 数组本身是引用数据类型。
- 数组中的元素可以是任何数据类型,包括基本数据类型和引用数据类型。
- 数组的长度一旦确定,就不能修改了。
3. 数组 静态初始化和动态初始化
数组静态初始化如下:
public static void main(String[] args) {
int[] ids;
ids = new int[]{1,2,3,4,5,6};
//静态初始化,就是数组的初始化和数组元素的赋值操作同时进行了。
}
数组动态初始化如下:
public static void main(String[] args) {
String[] str = new String[5];
//动态初始化,数组的初始化和数组元素的赋值操作分开进行
}
4. 获取数组长度 和 遍历数组
length获取长度,for循环遍历数组。
public static void main(String[] args) {
String[] str = new String[5];
str[0] = "张三";
str[1] = "张四";
str[2] = "张五";
str[3] = "张六";
str[4] = "张七";
// 获取第二个字符
System.out.println(str[0].charAt(1));
// 获取长度
System.out.println(str.length);
// 遍历数组
for(int i=0;i<str.length;i++) {
System.out.println(str[i]);
}
}
//三
//5
//张三
//张四
//张五
//张六
//张七
5. 不同类型数组的默认值
public static void main(String[] args) {
//int型数组默认为0
int[] in = new int[5];
for(int i=0;i<in.length;i++) {
System.out.print(in[i]);
}
System.out.println();
System.out.println("******************");
//short型数组默认为0
short[] sh = new short[5];
for(int i=0;i<sh.length;i++) {
System.out.print(sh[i]);
}
System.out.println();
System.out.println("******************");
//float型数组默认为0.0
float[] fl = new float[5];
for(int i=0;i<fl.length;i++) {
System.out.print(fl[i]);
}
System.out.println();
System.out.println("******************");
//char型数组默认为0或'\u0000' ,而非'0' ,这里默认不显示的!!
char[] ch = new char[5];
for(int i=0;i<ch.length;i++) {
System.out.print("----"+ch[i]+"---- ");
}
if(ch[3] == 0)
System.out.println("验证是否等于0,是!!");
System.out.println("******************");
//boolean类型数组默认是false
boolean[] bool = new boolean[5];
for(int i=0;i<bool.length;i++) {
System.out.print(bool[i]+" ");
}
System.out.println();
System.out.println("******************");
//String类型数组默认为null
String[] str = new String[5];
for(int i=0;i<str.length;i++) {
System.out.print(str[i]+" ");
}
System.out.println();
System.out.println("******************");
}
6. 数组的内存解析
7. 多维数组
多维数组,从数组底层的运行机制来看,其实没有多维数组。
多维数组很简单,就是一层一层套。
像二维数组,就可以简单分为外层数据元素和内层数组元素。
public static void main(String[] args) {
//二维数组的静态初始化
int[][] arr = new int[][] {{1,2,3},{4,5},{7,8}};
//二维数组的动态数组化
String[][] arr1 = new String[3][2];
String[][] arr2 = new String[3][];
//这里注意,前面的数字3必须写,后面可以不用写,这就可以当成一个一维数组来看。
//String[][] arr3 = new String[][3]; //这就是错误的!!!!
}
8. 二维数组获取长度 和 遍历数组
public static void main(String[] args) {
//二维数组的静态初始化
int[][] arr = new int[][] {{1,2,3},{4,5},{7,8}};
//对于arr而言,length 其实就是查看里面有几个数组
System.out.println(arr.length); // 3
//对于arr[1]而言,length就是查看第二个数组arr[1]的长度为多少
System.out.println(arr[1].length); //2
System.out.println("***********");
//遍历二维数组
for(int i=0;i<arr.length;i++) {
for(int j=0;j<arr[i].length;j++) {
System.out.print(arr[i][j] + ",");
}
System.out.println();
}
}
// 3
// 2
// ***********
// 1,2,3,
// 4,5,
// 7,8,
9. 多维数组的默认值
其实和上面的数组默认值是一样的。只不过这里注意的是像arr[0],这是返回的地址!!!
public static void main(String[] args) {
int[][] arr = new int[4][3];
//arr[0]的默认值是一个地址
System.out.println(arr[0]); //[I@7d6f77cc , 这里解释一下I,意思就是int型!
//int型的arr[0][0]的默认值为0
System.out.println(arr[0][0]); // 0
//像这种没有列只有行的,就是null了
double[][] arr = new double[4][];
System.out.println(arr[0]); //null
}
10. 二维数组的内存解析
其实就是一个arr1总地址,arr1[0]保存arr1[0]数组的地址信息,一次类推。
此外数组的写法还有一下几种形式:
11. 数组赋值
对于赋值而言,array2并不是复制了一份array1,而仅仅指向了和array1相同的地址而已!!
public static void main(String[] args) {
int array1[][] = new int[][] {{1,2,3},{4,5},{6}};
int[][] array2;
array2 = array1;
//array2并不是复制了一份array1,而仅仅指向了和array1相同的地址而已!!
//这一点要记住!!!
}
12. 数组的复制
使用for循环来进行复制!!!
public static void main(String[] args) {
String array1[][] = new String[][] {{"aa","bb","cc"}};
String[][] array2 = new String[array1.length][];
//复制array2
for(int i=0;i<array1.length;i++) {
array2[i] = array1[i];
}
//遍历array2
for(int i=0;i<array2.length;i++) {
for(int j=0;j<array2[i].length;j++) {
System.out.print(array2[i][j]+" ");
}
}
}
13. 数组算法 线性查找
线性查找就是从头到尾查找一边。
public static void main(String[] args) {
String arr[] = new String[] {"aa","bb","cc"};
String str = "bb";
boolean isFlag = true;
//线性查找就是从头到尾的查找方式
for(int i=0;i<arr.length;i++) {
if(str.equals(arr[i])) {
System.out.println("找到了指定的元素,位置为:"+i);
isFlag = false;
break;
}
}
if(isFlag) {
System.out.println("未查询到!!");
}
}
14. 数组算法 二分法查找
二分法查找有一个前提,就是所要查找的数组必须有序(从小到大)。
public static void main(String[] args) {
//二分法查找:
//二分法查找一定一有序的数组!!
int[] arr = new int[] {-100,10,15,16,24,56,3333};
int dest = 24;
int head = 0;
int end = arr.length -1;
boolean isFlag = true;
while(head <= end) {
int middle = (head + end)/2;
if(dest == arr[middle]) {
System.out.println("找到指定元素,位置为:"+ middle);
isFlag = false;
break;
}else if(arr[middle] > dest) {
end = middle - 1;
}else {
head = middle + 1;
}
}
if(isFlag) {
System.out.println("该数组未查询到!!!");
}
}
15.排序 算法的优劣
16. 冒泡排序
public static void main(String[] args) {
//冒泡排序
int[] arr = new int[] {43,32,76,-10,0,-123,40,22,98,-98};
//外层for循环是保证几轮,开始就从头到尾,把最大的数放到最后,下次在进行就不用再看最后一个最大的数了。
for(int i=0;i<arr.length-1;i++) {
//内层for循环负责交换
for(int j=0;j<arr.length-1-i;j++) {
if(arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+"\t");
}
}
17. 快速排序
18. Arrays数组工具类
public static void main(String[] args) {
int[] arr = new int[] {43,32,76,-10,0,-123,40,22,98,-98};
int[] arr1 = new int[3];
//Arrays.equals(xxx,xxx2)比较两个数组是否相等
System.out.println(Arrays.equals(arr,arr1));
//Arrays.toString(xxx)输出数组信息
System.out.println(Arrays.toString(arr));
//Arrays.fill(xxx,xx)给数组填充内容
Arrays.fill(arr1, 10);
System.out.println(Arrays.toString(arr1));
//Arrays.sort(xxx)给数组排序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
//binarySearch(xxx,xxx)二分查找,得到索引
int[] arr2 = new int[] {1,2,3,4,5,6,7,8,9,10};
System.out.println(Arrays.binarySearch(arr2, 9));
// false
// [43, 32, 76, -10, 0, -123, 40, 22, 98, -98]
// [10, 10, 10]
// [-123, -98, -10, 0, 22, 32, 40, 43, 76, 98]
// 8
}
提一句:java不能像python一样 -1访问最后一个,不能混淆。