Java——基础知识总结（方法、数组篇）

Java基础语法知识总结

Java八大基本数据类型

整数类

byte java使用过程中使用最少的数据类型,它在内存中占用1个字节,也就是8位(bit),值得范围是:-128~127,也就是-2的7次方到2的7次 方减一,默认值0。
short 短整型,它在内存中占用的是2个字节,16位,值得取值范围是-32768~32767,也就是-2的15次方到2的15次方减一,默认值0。
int 整型,在内存中占4个字节,32位,取值范围-2147483648~2147483647,也就是-2的31次方到2的31次方减一,默认值0。
long 长整型,在内存中占8个字节,64位,值的取值范围是-2的63次方到2的63次方减一,默认值要注意了,因为是长整型,所以默认是虽说是0,但是准确的说是0L,必须要加上L来表示它是long类型,不加就成了int类型了.

逻辑类

boolean 布尔类型,它比较特殊,布尔类型只允许存储true(真)或者false(假),不可以用0或者非0表示，可以使用 1 bit 来存储，但是具体大小没有明确规定。JVM 会在编译时期将 boolean 类型的数据转换为 int，使用 1 来表示 true，0 表示 false。JVM 支持 boolean 数组，但是它是通过读写 byte数组来实现的。

文本类

char 字符类型,它在内存中占用2个字节,也就是16 bit,因为java本身的字符集不是用ASCII码来存储的, 而是用的16位的Unicode字符集,所以它的字符存储范围也就是’\u0000 – u\ffff’,默认值呢?就是’\u0000’。在实际编程中，赋值时使用单引号( ’ ’ )。

浮点类

float 单精度浮点型, 在内存中占4个字节(32位),主要用来存储小数,但是有限制,有效小数位只有6~7位,默认是0.0f ,取值范围是:3.402823e+38 ~ 1.401298e-45（e+38表示是乘以10的38次方,同样,e-45表示 乘以10的负45次方)。
double 双精度浮点型,在内存中占8个字节,64位,也是用来存储小数的,默认是0.0,取值范围是1.797693e+308 到4.9000000e-324（e+308表示是乘以10的308次方,同样,e-324表示乘以10的负324次方)。
注意： 不声明小数类型的情况下,默认为double类型。
数据类型的转换(boolean不参与数据类型的转换)
char(16 bit)
|
byte(1 bit) -> short(16 bit) -> int(32 bit) -> long(64 bit)
| |
float(32 bit) double(64 bit)
注意： 根据类型所占内存大小,小可转大，大转小会失去精度。
数据类型默认值
整型： 0
浮点型： 0.0
布尔型： false
Char： ‘ ’（空）
引用数据类型： null

自定义方法

方法的声明： 解决一类问题的代码有序的组合，是一个功能模块。
组成：访问修饰符 返回类型 方法名（形参）{方法体}
例：

public static void add(int a,int b) {
        int result=a+b;
        System.out.println("和是"+ result);
    }

方法的分类

无参无返回值方法
例:

public static void print(String[] args) {
System.out.println("输出语句");
}

无参有返回值方法
例:

public static boolean Isture() {
    //中间省略一段判断数据结果的代码，判断为假，结束并返回一个值
return false;
}

有参无返回值方法
例：

public static void add(int a) {
a++;
}

有参有返回值方法
例：

public static int cal(int a,int b) {
return a-b;
}

关键字return、break、continue的区别
return 结束方法
break 结束本次循环
continue终止本次循环继续下次循环

方法的调用

例：

//方法名（）;
add（）;

方法的重载

重载的条件
形参类型、个数、顺序不同构成重载；只有返回值不同不构成重载。
例：

public class Name {
        public static void main(String[] args){

            System.out.println(getSum(1,2,3));
            System.out.println(getSum(1.1,2.2,2.3));
        }
        public static int getSum(int a,int b){
            System.out.println("两个参数");
            return a+b;
        }
        public static int getSum(int a,int b,int c){
            System.out.println("三个参数");
            return a+b+c;
        }
        public static double getSum(double a,double b,double c){
            System.out.println("三个参数");
            return a+b+c;
        }
}

递归（非常消耗内存）

结构：
定义递归头（什么时候不调用自身的方法)
递归体(什么时候需要调用自身)
例1：

public static int fun(int n) {
	//递归头
	if(n==1||n==0){
		return 1;
	}else{
	//递归体
		 return fun(n-1)*n;
	}
}
//自己调自己

例2：

public class Name {
    public static void main(String args[]) {
        print(9);
    }
    //递归打印九九乘法表
    public static void print(int i) {
        if (i==1) {
            System.out.println("1*1=1 ");
        } else {
            print(i-1);
            for (int j=1; j<= i; j++) {
                System.out.print(j+"*"+i+"="+j*i+"\t");
            }
            System.out.println();
        }
    }
}

数组

数组的定义

长度的属性关键字： length
定义数据类型为int的数组
例：

int[] arr=new int();	

数组的动态初始化

先确定数量后赋值，一旦确定长度，不可改变。
例：

String[] arr=new String[6];
	arr[0]="你好";
	arr[1]="哈罗";

数组的静态初始化

例：

String[] arr=new String[]{“你好”,“哈罗”} 

数组遍历

遍历： 按照一定规则取出数组中的内容。
例：

public static void main(String[] args) {
	double[] arr={1.0,1.1,1.2};
	for(int i=0;i<arr.length;i++){
	System.out.println(arr[i]);
	}
}

增强for循环: for（数据类型 变量名：要遍历的对象）这里变量名是要遍历的直接类容。
例：

double[] arr={1.0,1.1,1.2};
for（double i:arr）{
System.out.println(i)；

}

数组排序

冒泡排序： 每次分别拿两个数进行比较，把大的放到后面，全部比较一次后，确保最大的数放到最末尾。
例:

public class Test01 {
	public static void main(String[] args) {
		int[] add= {3,9,5,3,8,6,2,4,6,2,85,8,3};
		sortBubble(add);//调用方法
		System.out.println(Arrays.toString(add));
	}
	public static void sortBubble(int[] add) {
		for(int a=0;a<add.length;a++) {
	 //循环下一for，循环一次下一个for循环一遍，直到下一个for不满足条件，跳出
			for(int j=0;j<add.length-1;j++) {//索引位置
				if(add[j]>add[j+1]) {//索引位置的值进行比较
					//两个索引位置的值进行互换
					int tep=add[j+1];//建立一个临时的值
						add[j+1]=add[j];
						add[j]=tep;
						
				}
			}
		}
	}
}

选择排序： 拿第一个数分别和接下来剩下的数进行比较，保留其中最小数的索引，然后把它和当前正在对比的数进行互换。
例：

//int[] add= {3,9,5,3,8,6,2,4,6,2,85,8,3};
	public static void sortSelect(int[] add) {
		for(int i=0;i<add.length;i++) {//索引为0开始
			int minIndex=i;   //每执行一次，就保留当前最小数索引
			for(int j=i;j<add.length;j++) {
				if(add[j]<add[minIndex]) {//当索引j与minIndex为0时，条件不成立
					//当j索引位置的值小于minIndex索引位置的值，向下执行
					minIndex=j;//第二个循环循环一遍，拿到最小数索引，向下执行交换
				}
			}
			//交换把最小数排数组第一位
			int tep=add [minIndex];
			add [minIndex]=add[i];
			add [i]=tep;	
		}
	}

二维数组及遍历

定义格式

动态初始化： 数据类型[ ][ ] 二维数组名=new 数据类型[一维长度][二维长度];
注意： 一维必须给值。
静态初始化： 数据类型[ ][ ] 二维数组名=new 数据类型[ ][ ]{{“1”,“2” },{“3”,“4”},…};

二维数组遍历

例：

public class Array02 {
	public static void main(String[] args) {
		int[][] arr= {{1,3,5},{3,1},{4}};
		System.out.println("普通for里面嵌套增强for");
		for(int i=0;i<arr.length;i++) {//i表示外层数组的索引
			for(int p:arr[i]) {//增强for循环
				System.out.println(p);
			}	
		}
	}
}

Arrays（数组）工具类的使用

Arrays.toString() 
// 把数组中的内容用字符串的形式返回
Arrays.equals() 
// 比较两个数组的内容是否相等
Arrays.deepToString()	
//针对多维数组使用
Arrays.deepEquals(a,b)	 
//针对多维数组使用
Arrays.fill(数组,值）
//将指定的数据类型的值分配给指定的数据类型型数组的每个元素
Arrays.fill(数组,左边索引,右边索引,值);
//将指定的值分配到指定数组的指定范围（前闭后开)
Arrays.parallelSort(数组);
//将指定的数组排序
Arrays.binarySearch(数组,值)
//二分查找法

注意： 使用二分查找法，首先保证数组是有序的

常量final

定义： 用final修饰的，在程序运行期间值不会改变。