JAVASE基础回顾总结（二）

JAVASE基础回顾总结（二）

1.运算符：

（1）面试题：s+=1 不等价于：s=s+1;而是等价于s=（s的数据类型）s+1;

（2）面试题：&和&&（|和||）区别：结果相同，但是&&（||）是短路运算；

2.选择结构if和switch如何选择？

（1）if的使用场景：

针对结果是boolean类型的判断；因为switch（byte、short、int、char、String、枚举）只能判断这几种类型；

针对一个范围的判断；

针对几个常量值的判断；

（2）switch的使用场景：

针对几个常量值的判断；

3.（1）求和思想：

定义两个变量，一个变量用于存储第一个加数，第一个加数实际上保存的是以前的所有数据和，默认初始值为0；

一个变量用于存储加数，这个变量其实就是每次数据变化的值；

4.for循环和while循环的区别：

（1）如果你想在循环结束后继续使用控制条件的那个变量，用while循环，否则使用for循环；

（2）不知道选什么时就用for循环，因为变量及早的从内存中消失，提高了内存使用效率；

（3）如果是一个范围的用for循环非常明确；如果循环次数不明确的使用while循环较为合适；

5.控制跳转语句：

（1）break:（中断）：①在switch语句中；②在循环语句中，跳出当前循环（循环语句中加入if判断的情况）③离开上面两个场景使用无意义；

（2）continue：（继续）：①在循环语句中，跳出本次循环，继续下次循环；

（3）return：（退出方法）：结束一个方法，跳转到上层调用该方法的地方，return后面的语句不执行；

6.方法的思想：

（1）方法不调用不执行；

（2）方法之间是平级关系，不能嵌套定义；

7.数组：

（1）定义：存储同一种数据类型的多个元素的容器或集合；

（2）定义格式：（此时数组还未初始化，不能使用）

①数据类型 [] 数组名；

②数据类型 数组名[];

（3）数组的初始化：

定义：所谓初始化就是为数组中的数组元素分配内存空间，并为每个数组元素赋值；

初始化格式：

①动态初始化：初始化时只指定数组的长度，由系统为数组分配初始值；

数据类型 [] 数组名 = new 数据类型[数组长度]；（数组长度即数组中元素个数）

举例：int [] arr1 = new int [3]; arr[0] = 1;arr[1] = 1; arr[2] = 1;

②静态初始化：初始化时指定每个元素的初始值，由系统决定数组长度；

格式：数据类型 [] 数组名 = new 数据类型[]{值1，值2，…}

举例：int [] arr2 = new int[]{1,2,3}

简化格式：数据类型 [] 数组名 = {值1，值2，…}

举例：int [] arr2 ={1,2,3}

②错误始化化：静态和动态初始化一起使用：

格式：数据类型 [] 数组名 = new 数据类型[数组长度]{值1，值2，…}

举例：int [] arr2 = new int[3]{1,2,3}

（4）数组的遍历：

①方式一：使用for循环和数组的length属性；

（5）数组的一些操作：

①获取数组最大值：（参考代码如下）：

/*
数组获取最值(获取数组中的最大值最小值)

分析：
A:定义一个数组，并对数组的元素进行静态初始化。
B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。
C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
D:最后参照物里面保存的就是最大值。
*/
public class ArrayMax {
public static void main(String[] args) {
int arr[] = {12,56,23,21,98,14,13,100};
System.out.println(new ArrayMax().getArrayMax(arr));

}

public int getArrayMax(int[] arr) {
int max = arr[0];
for(int i=1; i<arr.length; i++){
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
}

②数组元素逆序 （参考代码如下：两种方式）

/*
* 实现：数组元素逆序 (就是把元素对调)
*/
public class ArrayReverse {
public static void main(String[] args) {
int[] arr = {1,45,32,21,67};
//new ArrayReverse().reverseArrayOne(arr);
new ArrayReverse().reverseArrayTwo(arr);
for(int i=0; i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}

/*
* 实现一：
*  数组元素逆序 (就是把元素对调)

分析：
A:定义一个数组，并进行静态初始化。
B:思路
把0索引和arr.length-1的数据交换
把1索引和arr.length-2的数据交换
...
只要做到arr.length/2的时候即可。
*
*/
public void reverseArrayOne(int[] arr) {
int tmp;
for(int i=0; i<arr.length/2;i++){
tmp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = tmp;

}
}

public void reverseArrayTwo(int[] arr) {
int tmp;
for(int start=0,end=arr.length-1; start<end;start++,end--){
tmp = arr[start];
arr[start] = arr[end];
arr[end] = tmp;

}
}
}

③实训数组操作总结:

package com.utils;
/**
* 数组相关的操作:
* @author 任志燕
* 2017年6月20日
*
*/
public class ArrayTest {
/**
* 插入排序(元素是int型的)
* @param beforeInsertArr:int[] 排好序的数组
* @param afterInsertArr:int[] 插入后的数组，需要定义，且需要声明长度(eg:int[] afterInsertArr = new int[beforeInsertArr+1])
* @param type:String 取值只有两个:asc(升序)或desc(降序),指明beforeInsertArr的排序方式
* @param num:int 待插入的数据
* @return void
*/
public static void insertNum(int[] beforeInsertArr,int[] afterInsertArr,String type,int num) {
//1.将插入前的数组的值赋给插入后数组
for (int i = 0; i < beforeInsertArr.length; i++) {
afterInsertArr[i] = beforeInsertArr[i];
}
//2.默认插入数字的位置是插入后数组的最后一个位置
int index = beforeInsertArr.length;
//3.找插入字符的位置
for (int i = 0; i < beforeInsertArr.length; i++) {
if ("asc".equals(type)) {
<
d4c3
span class="hljs-keyword">if (num < beforeInsertArr[i]) {
index = i;
break;
}
}else if ("desc".equals(type)) {
if (num > beforeInsertArr[i]) {
index = i;
break;
}
}
}
//4.将插入字符位置以后的元素后移
for (int i = afterInsertArr.length-1; i > index; i--) {
afterInsertArr[i] = afterInsertArr[i-1];
}
afterInsertArr[index] = num;
}

/**
* 插入排序(元素是char型的)
* @param beforeInsertArr:char[] 排好序的数组
* @param afterInsertArr:char[] 插入后的数组，需要定义，且需要声明长度(eg:char[] afterInsertArr = new char[beforeInsertArr+1])
* @param type:String 取值只有两个:asc(升序)或desc(降序),指明beforeInsertArr的排序方式
* @param :character char 待插入的数据
* @return void
*/
public static void insertChar(char[] beforeInsertArr,char[] afterInsertArr,String type,char character) {
for (int i = 0; i < beforeInsertArr.length; i++) {
afterInsertArr[i] = beforeInsertArr[i];
}
int index = beforeInsertArr.length;
for (int i = 0; i < beforeInsertArr.length; i++) {
if ("asc".equals(type)) {
if (character < beforeInsertArr[i]) {
index = i;
break;
}
}else if ("desc".equals(type)) {
if (character > beforeInsertArr[i]) {
index = i;
break;
}
}
}
for (int i = afterInsertArr.length-1; i > index; i--) {
afterInsertArr[i] = afterInsertArr[i-1];
}
afterInsertArr[index] = character;
}
/**
* 求数组中元素最大值
*
* @param arrNum int[]
* @return int
*/
public static int getMax(int[] arrNum) {
int max = arrNum[0];
for (int i = 1; i < arrNum.length; i++) {
if (max < arrNum[i]) {
max = arrNum[i];
}
}
return max;
}

/**
* 求数组中元素最小值
*
* @param arrNum int[]
* @return int
*/
public static int getMin(int[] arrNum) {
int min = arrNum[0];
for (int i = 1; i < arrNum.length; i++) {
if (min > arrNum[i]) {
min = arrNum[i];
}
}
return min;
}

/**
* 冒泡排序(升序排列)
* @param arr int[]
* @return void
*/
public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-1-i; j++) {
if (arr[j] > arr[j+1]) {
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}

/**
* 冒泡排序(降序排列)
* @param arr int[]
* @return void
*/
public static void bubbleSort2(int[] arr) {
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-1-i; j++) {
if (arr[j] < arr[j+1]) {
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}

/**
* 逆序打印数组元素
* @param arr
* @return void
*/
public static void reversePrint(int[] arr) {
for (int i = arr.length-1; i >= 0; i--) {
System.out.print(arr[i]+" ");
}
}

public static void main(String[] args) {
int[] arr = {10,20,5,64,32};
reversePrint(arr);

}

}

8.java参数传递：

（1）java中的参数传递全是值传递；

（2）基本类型：形式参数的改变对实际参数没影响；

（3）引用类型：形式参数的改变直接影响实际参数；