基础知识以及数组

java软件安装知识总结：

一.JVM,JRE,JDK的区别？

JVM -- java virtual machine   java虚拟机

JRE -- java runtime environment      java运行环境

JDK -- java development kit     java工具包

 

JVM (Java Virtual Machine，Java虚拟机），它是一个虚构出来的计算机,是通过在实际的计算机上仿真模拟各种计算机功能来实现的   JVM 可以编译你写的java代码并执行编译出来的字节码文件

JRE（Java Runtime Environment，Java运行环境），运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。  JRE提供的类库包括有像java.lang，java.until包这样常用的类库。  

JDK(Java Development Kit)是Sun Microsystems针对Java开发员的产品。 java的开发工具集

 

二、classpath和path区别？

Path：java程序字节码文件的路径，先在当前目录找执行程序，如果没有，再到path指定目录中去寻找。

Classpath：java编译工具的安装路径，需要这个工具时，就去classpath路径下去找。先在classpath路径下找，找到了，即使当前目录有，也不会执行到。并且只有classpath的值后面加了分号才会当当前目录中来寻找执行程序。

 

java基础知识 关键字，常量，标示符，流程控制

一、关键字

意思：被java赋予特殊含义的的单词。

特点：其中的所有字母均为小写。

注意：用户自己定义的名称不能与关键字冲突。

特殊：main不是关键字，但是虚拟机可识别

二、标示符

意思：在程序中定义的一些名称，如类名

规则:由26个英文字母大小写，数字，0~9数字，下划线（_），美元符号（$）组成。

注意：1.数字不能开头

     2.关键字不能用

     3.java严格区分大小写

java中的名称规范：

包名：小写

类名‘接口名：首字母大写

变量名、函数名：多单词组成时，第一个单词字母小写，第二个单词字母大写，形成驼峰状

常量名：所有字母都大写

三、常量

意思：表示不能改变的数值

分类：整数常量 小数常量 布尔常量 字符常量 字符串常量 null常量（只有一个数值null）

整数：

10进制 0-9

8进制 0-7

16进制 0-9 A-F OX开头

二进制 0,1

8进制是二进制的缩短形式，进制越大，表现形式越短；（三个二进制位表示1位）0开头

16进制：4个二进制代表1位

八进制转化成十六进制，可以先变成二进制在化成十六进制。（把二进制当做转化的桥梁）

为什么没有9进制？以2的整数倍，好算。

没有32进制，因为元素太多，不好记

负数：二进制取反加1，负数最高位位1

四、变量

意思：就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间（对具体的数据进行分类，java是强类型语言）。

如何开辟空间？

通过明确数据类型（如：int），变量名称（如：a），数据（如：5）来完成

注意：java是强类型语言，对于每一种数据类型都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。

五、类型转换

byte b=2;

b=b+3;// 应该强制转化

记住：容量小的自动提升为容量大的，因为仍然可以装下；

b= (byte)(b+3);
以下代码哪个是正确的？为什么？
a. byte b = 1 + 1;     
b. byte b = 1; b = b + 1;
c. byte b = 1; b = b += 1;    
d. byte b = 1; b = ++b;

答：a，c，d正确；
选项a,结果和2，然后检查是否在byte范围（-128~127），一看在，所以正确；
选项b中，b+1的结果默认转换为int型，int型不能直接转换为byte型，需强制转换。

应改为：byte b=1;b=(byte)(b+1);
b=b+1是两次运算，b被提升为int型，运算结果为int，无法赋值给byte类型
选项c中，b+=1是一次运算，包含了一个隐藏的类型转换，相当于 b=(byte)(b+1);
选项d中，b=++b是一次运算，也包含了一个隐藏的类型转换

六、运算符

易混点：

&和&&的区别：

        单&时，无论左边是true是false，右边都进行运算；

        双&时，如果左边为true，右边参与运算，如果左边为false，那么右边不参与运算。

“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。

左移：<<；空位补0，被移除的高位丢弃，空缺位补0。

右移：>>；被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1。

无符号右移：>>>；被移位二进制最高位无论是0或者是1，空缺位都用0补。

七、流程控制(for if while)疑难点

1.if else是做单选题，if结构块和else结构块只能执行一个，while是条件判断，只有条件满足才执行循环体；

注意：

(1)当if后面的语句用else和不用else时，是有区别的：

如果有else意思是if语句不成立才执行else，如果没有else意思是if成立不成立，都要执行，虽然很简单的道理，但有时候也会犯晕；

(2)esle子句不能单独存在，else总是与离他最近的if匹配，如果实在不能分，就全部写成多if子句也可以，我们一般都判断两三个，不会太多；

2.if else结构的简写格式

    变量=（条件表达式）？表达式1：表达式2；

三元运算符：（必须有结果）

好处：可以简化if else代码（但有局限性）

弊端：因为是一个运算符，所有运算必要有一个结果；

3.for与while的区别：

(1)变量有自己的作用域，对于for来讲，如果将用于控制循环的增量定义在for语句中，那么该变量只在for语句内有效，for语句执行完毕，该变量在内存中被释放；

(2)for和while可以互换，如果需要定义循环增量，用for更为合适；当要对某些语句执行很多次时，就使用循环语句；

3.Switch总结

(1)switch语句选择的数据类型只有四种：char，int，byte，short，当具体数比较少时用switch；

4.注意：什么时候使用循环结构呢？当对某些代码执行多次时，使用循环结构完成，当对一个条件进行一次判断时，可以使用 if 语句，当对一个条件迚行多次判断时，可以使用 while 语句，在使用循环时， 一定要明确哪些语句需要参不循环， 哪些不需要， 循环通常情况下， 需要定义条件，需要控制次数。

5.累加思想：

通过变量记录每次变化的结果，通过循环的形式，进行累加动作；

6.计数器思想：

通过一个变量记录数据的状态变化，也需要循环完成；

7.记住：(1)break和continue作用的范围（应在循环体内）

             (1)break和continue单独存在，下面不能有任何语句

习题

./**考察：对变量的应用* 编程求：1+（1+2）+（1+2+3）+. . .+（1+2+3+. . .+100）*/void addAdd(){int sum=0;//总和for(int i=1;i<=100;i++){int tempSum=0;//临时和for(int j=1;j<=i;j++){tempSum+=j;}sum+=tempSum;}System.out.println(sum);}/**2.* 编程求：1！+2！+3！+4！+. . .+15！**/private void addFactorial() {long result=0;for(int i=1;i<=15;i++){int temp=1;for(int j=1;j<=i;j++){temp*=j;}result+=temp;}System.out.println(result);}}

数组：

数组的定义：就是一个容器，是引用类型，是 数组是相同类型数据的集合如int[] x其中，int是存放的数据类型，x是数组类型

数组的好处：自动给数组中的元素编号

数组的特点：

1.长度固定，一旦被创建它的长度就是不可改变的；

2.其元素类型必须是相同类型，不允许出现混合类型；

3.数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型；

4.数组变量是引用类型，数组也可以看做是对象，数组中的每个元素相当于该对象的成员变量，数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组本身是在堆中的。

5.内有初始化值null，内有地址值，还有垃圾回收机制

数组的下标合法区间是[0,length-1]。
数组的拷贝：System.arrayCopy（源数组，从哪开始，目标数组，从哪开始贴，粘几个） 。
数组排序：Arrays.sort（被排序的数组） 。
二分法查找：Arrays.binarySearch（哪个数组，数组中的什么元素） 。
填充：Arrays.fill（a， 2， 4, 100） 。//将数组a中2到4的索引的元素替换为100
获取数组的长度：数组.length，如a.length，获取数组a的元素个数；a[0].length，表示获取二维数组中第一个数组的长度。
数组的遍历：可以使用for循环戒者for嵌套循环（对于二维数组） ，也可以使用增强for循环来对数组进行遍历，增强for循环格式： for（变量类型 变量名：被遍历的数组）

关于排序，查找，最值的算法：
1.选择排序
思路：在一堆数中我们通过一次筛选选中最小的，然后从剩下的数中再此筛选，选出最小的
代码如下：
给定一个数组{1,9,5,8,6}，排序后输出，形式为[*,*,*]

public class ArrayTest {public static void SelectSort(int[] arr) {//减1是因为最后一个不用比 for (int i = 0; i < arr.length - 1; i++) {for (int j = i + 1; j < arr.length; j++) {if (arr[j] < arr[i]) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}}}public static void printArray(int[] arr) {System.out.print("[");for(int i=0;i<arr.length;i++) {if(i!=arr.length-1)System.out.print(arr[i]+",");elseSystem.out.print(arr[i]+"]");}}public static void main(String[] args) {int[] arr = {1,9,5,8,6};SelectSort(arr);printArray(arr);}}

2.冒泡排序
思路：每次比较相邻元素，每次内层循环最大数沉到最下面，小树不断上浮，形象称为冒泡
代码如下：

public class ArrayTest {public static void bubbleSort(int[] arr) {for(int i=0;i<arr.length-1;i++) {//-i让每一次的比较的元素减少，-1避免数组越界for(int j=0;j<arr.length-i-1;j++) {if(arr[j]>arr[j+1]) swap(arr,j,j+1);}}}//交换两个数，技巧:int temp = arr[a],下一行以arr[a]开头public static void swap(int[] arr,int a,int b) {int temp =arr[a];arr[a]=arr[b];arr[b]=temp;}public static void printArray(int[] arr) {System.out.print("[");for(int i=0;i<arr.length;i++) {if(i!=arr.length-1)System.out.print(arr[i]+",");elseSystem.out.print(arr[i]+"]");}}public static void main(String[] args) {int[] arr = {1,9,5,8,6};bubbleSort(arr);printArray(arr);}}3二分查找(1)一般查找public class A {public static int getIndex(int[] arr, int key) {for (int i = 0; i < arr.length; i++) {if (arr[i] == key)return i;}return -1;}public static void main(String[] args) {int[] arr = { 1, 3, 5, 8, 9 };System.out.println(getIndex(arr, 3));}}

(2)二分查找
方法一：

public class A {public static int halfSearch(int[] arr,int key) {int min,max,mid;min=0;max=arr.length-1;mid=(min+max)/2;//折半while(arr[mid]!=key) { //如果要查找的数据，比中间的数据大，则从后一半中查找min=mid+1;简单规律记忆：大于号，min赋值，mid加1，是递增的if(key>arr[mid])min=mid+1; //如果要查找的数据，比中间的数据小，则从前一半中查找max=mid-1;简单规律记忆：小于号，max赋值，mid减1，是递减的else if(key<arr[mid])max=mid-1;if(min>max)return -1;mid = (min+max)/2;}//找到返回mid return mid;}public static void main(String[] args) {int[] arr = { 1, 3, 5, 8, 9 };System.out.println(halfSearch(arr, 2));}}

方法二：循环条件变为min<=max

public class A {   public static int halfSearch_2(int[] arr,int key) {           int min,max,mid;        min=0;max=arr.length-1;while(min<=max) {mid=(min+max)/2;if(key>arr[mid])min=mid+1;else if(key<arr[mid])max = mid-1;else return mid;}return -1;     }public static void main(String[] args) {int[] arr = { 1, 3, 5, 8, 9 };System.out.println(halfSearch_2(arr, 3));}}

 

给定一个有序的数组，如果往该数组中存储一个元素，并保证这个数组还是有序的，

那么个元素的存储的角标为如何获取。

只要没最后一次的min值返回即可

public class A {public static int getIndex_2(int[] arr,int key) {int min,max,mid;min=0;max=arr.length-1;while(min<=max) {mid=(min+max)/2;if(key>arr[mid])min=mid+1;else if(key<arr[mid])max = mid-1;else return mid; }return min;      }public static void main(String[] args) {int[] arr = { 1, 3, 5, 8, 9 };System.out.println(getIndex_2(arr, 4));}}

4.数组求最大值、最小值（三种方法）
方法一：
思路：(最小值思路与最大值相同)
1.获取最值需要比较，每一次比较都会有一个较大的值，因为
该值不确定，所以通过一个变量进行存储；
2.让数组中的每一个元素都和这个变量比较，如果大于变量的值，
就用该变量记录较大值；
3.当所有的元素都比较完成，那么该变量存储的值就是数组中的最大值；
步骤：
1.定义变量，初始化为数组中任意一个元素即可；
2.通过循环语句对数组遍历；
3.在遍历过程中，定义判断条件，如果遍历的元素比变量中的大，就赋值
给该变量；

需要定义一个功能来完成，以便提高复用性。
1.明确结果，数组中的最大值
2.未知内容，一个数组，int[]

代码如下：
给定数组arr={1,56,8,2,5,}，求最大值与最小值。

public class ArrayTest {public static int getMax(int[] arr){int max = arr[0];for(int i=0;i<arr.length-1;i++) {if(arr[i]>max)max=arr[i];}return max;}public static int getMin(int[] arr) {int min = arr[0];for(int i=0;i<arr.length-1;i++) {if(arr[i]<min)min=arr[i];}return min;}public static void main(String[] args) {int[] arr={1,56,8,2,5,};System.out.println("方法一：------------");System.out.println("max:"+getMax(arr));System.out.println("min:"+getMin(arr));}}

方法二：
与方法一的不同点：
可以将临时变量初始化为0，这时我们获得的是数组最大值的角标；

public class ArrayTest {public static int getMax(int[] arr){int max = 0;for(int i=0;i<arr.length-1;i++) {if(arr[i]>arr[max])max=i;}return arr[max];}public static int getMin(int[] arr) {int min = 0;for(int i=0;i<arr.length-1;i++) {if(arr[i]<arr[min])min=i;}return arr[min];}public static void main(String[] args) {int[] arr={1,56,8,2,5,};System.out.println("方法一：------------");System.out.println("max:"+getMax(arr));System.out.println("min:"+getMin(arr));}}

方法三：
与前两个方法不同：通过定义系统最大值和最小值
MAX_VALUE：值为 231－1 的常量，它表示 int 类型能够表示的最大值。
MIN_VALUE：值为 －231 的常量，它表示 int 类型能够表示的最小值。

package com.itheima;public class ArrayTest {public static int getMax(int[] arr){int max = Integer.MIN_VALUE;for(int i=0;i<arr.length-1;i++) {if(arr[i]>max)max=arr[i];}return max;}public static int getMin(int[] arr) {int min = Integer.MAX_VALUE;for(int i=0;i<arr.length-1;i++) {if(arr[i]<min)min=arr[i];}return min;}public static void main(String[] args) {int[] arr={1,56,8,2,5,};System.out.println("方法一：------------");System.out.println("max:"+getMax(arr));System.out.println("min:"+getMin(arr));}}

5..大圈套小圈思想输出不同的图形

(1)输出“实心”长方形，“空心”长方形

package day01;/* * * 输出一个指定长宽的长方形；空心，非空心 */public class Rectangle {public static void rectangle(int chang,int kuan){if(chang<2||kuan<2)System.out.println("非法");else{for(int i=1;i<=kuan;i++)//本质：种植循环次数，即行数{for(int j=1;j<=chang;j++)// 本质：控制打印*的个数，即长{if(i==1||i==kuan||j==1||j==chang)System.out.print("* ");elseSystem.out.print("  ");}System.out.println();}}}public static void rectangle_1(int chang,int kuan){if(chang<2||kuan<2)System.out.println("不合法");else{for(int i=1;i<=kuan;i++){for(int j=1;j<=chang;j++){System.out.print("* ");}System.out.println();}}}public static void main(String[] args) {Rectangle.rectangle(6,5);System.out.println("-------------------");Rectangle.rectangle_1(6,5);}}

(2)输出带星的三星形

package day01;public class Sanjiaoxing {/* * 总结：尖朝上，改变循环体的条件， *     尖朝下，改变初始值的条件；每行输出数减1，只有初始值改变，输出数才会减1；每行输出数加1，只有改变循环体，输出数才会加1； *  * * * * * * * * * * * * * * * * * * * * *  */public static void sanjiaoxing_1(){for(int i=1;i<=6;i++){for(int j=i;j<=6;j++){System.out.print("* ");}System.out.println();}}/*      * * * * * * * * * * * * * * * * * * * * *  */public static void sanjiaoxing_2(){for(int i=1;i<=6;i++){for(int j=1;j<=i;j++){System.out.print("* ");}System.out.println();}}/* *  654321654326543654656 *  *  */public static void sanjiaoxing_3(){for(int i=1;i<=6;i++){for(int j=6;j>=i;j--){System.out.print(j);}System.out.println();}}/*122333444455555666666 *  *  */public static void sanjiaoxing_4(){for(int i=1;i<=6;i++){for(int j=1;j<=i;j++){System.out.print(i);}System.out.println();}}/* * * * * * *   * * * * *    * * * *     * * *      * *       *   *  */public static void sanjiaoxing_5(){for(int i=1;i<=6;i++){for(int j=1;j<=i;j++){System.out.print(" ");}for(int k=i;k<=6;k++){System.out.print("* ");}System.out.println();}}/*      *      * *     * * *    * * * *   * * * * *  * * * * * *  */public static void sanjiaoxing_6(){for(int i=1;i<=6;i++){for(int j=i;j<=6;j++){System.out.print(" ");}for(int k=1;k<=i;k++){System.out.print("* ");}System.out.println();}}public static void main(String[] args) {sanjiaoxing_6();}}

6..反转数组（首尾数字交换位置）

package day01;public class ReverseArr {public static void reverseArr(int[] arr){ //让首尾元素互换for(int start=0, end=arr.length-1;start<end;start++,end--){swap(arr,start,end);}}//交换两个数public static void swap(int[] arr,int a,int b){int temp=arr[a];arr[a]=arr[b];arr[b]=temp;}//打印public static void printArray(int[] arr){System.out.print("[");for(int x=0; x<arr.length; x++){if(x!=arr.length-1)System.out.print(arr[x]+", ");elseSystem.out.println(arr[x]+"]");}}public static void main(String[] args) {int[] arr={1,5,8,41,96};printArray(arr);reverseArr(arr);printArray(arr);}}

7.进制间的转化和数组中查表法的运用
(1)进制间转化

package day01;public class Jinzhiconvers {//十进制----二进制public static void toBin(int num){//使用stringbuffer的反转功能StringBuffer sb = new StringBuffer();while(num>0){sb.append(num%2);num=num/2;}System.out.println(sb.reverse());}//十进制-----十六进制public static void toHex(int num){StringBuffer sb = new StringBuffer();for(int x=0;x<8;x++){int temp =num&15;if(temp>9)sb.append((char)(temp-10+'a'));elsesb.append(temp);num=num>>>4;}System.out.println(sb.reverse());}public static void main(String[] args) {//toHex(60);toBin(6);}}

(2)查表法的运用

package day01;public class ChaBiaoFa {/** * // 0,1,2,3,4,5,6,7,8,9,A, B, C, D, E, F       // 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15        *         *  插标法：将所有的元素临时存储起来，建立对应关系        *  每一次&15后的值作为索引去查建立好的表，就可以找对应的元素        *  这样比“-10+‘a’”好多了        *  这个表怎么建立呢：        *  可以通过数组的形式来定义        *          *  结果反着，所有使用Stringbuffer；        *   查表法可以查负数 *///十进制-->十六进制。public static void toHex(int num){trans(num,15,4);}//十进制-->二进制。public static void toBinary(int num){trans(num,1,1);}//十进制-->八进制。public static void toOctal(int num){trans(num,7,3);}public static void trans(int num,int base,int offset)//bases是代表与上的数，偏移位offset{if(num==0){System.out.println("0");return;}//定义一个对应关系表。十六进制的表，包括了二进制，八进制的表char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};//定义一个临时存储的容器char[] arr = new char[32];//定义一个操作数组的指针，从最后一个位置存，就不用再翻转了int pos = arr.length;while(num!=0){int temp = num & base;arr[--pos] = chs[temp];num = num >>> offset;}for(int x=pos ;x<arr.length; x++){System.out.print(arr[x]);}System.out.println();}public static void main(String[] args) {toBinary(-10);toOctal(20);toHex(60);}}