基础知识以及数组
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基础知识 关键字，常量，标示符，流程控制
一、关键字
二、标示符
三、常量
以下代码哪个是正确的？为什么？
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。
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;i2.冒泡排序
思路：每次比较相邻元素，每次内层循环最大数沉到最下面，小树不断上浮，形象称为冒泡
代码如下：
public class ArrayTest {
public static void bubbleSort(int[] arr) {
for(int i=0;iarr[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 (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(keymax)
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
给定一个有序的数组，如果往该数组中存储一个元素，并保证这个数组还是有序的，
那么个元素的存储的角标为如何获取。
只要没最后一次的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(key4.数组求最大值、最小值（三种方法）
方法一：
思路：(最小值思路与最大值相同)
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;imax)
max=arr[i];
}
return max;
}
public static int getMin(int[] arr) {
int min = arr[0];
for(int i=0;i 方法二：
与方法一的不同点：
可以将临时变量初始化为0，这时我们获得的是数组最大值的角标；
public class ArrayTest {
public static int getMax(int[] arr){
int max = 0;
for(int i=0;iarr[max])
max=i;
}
return arr[max];
}
public static int getMin(int[] arr) {
int min = 0;
for(int i=0;i
方法三：
与前两个方法不同：通过定义系统最大值和最小值
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;imax)
max=arr[i];
}
return max;
}
public static int getMin(int[] arr) {
int min = Integer.MAX_VALUE;
for(int i=0;i 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("* ");
else
System.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();
}
}
/*
* 654321
65432
6543
654
65
6
*
*
*/
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();
}
}
/*
1
22
333
4444
55555
666666 *
*
*/
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(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'));
else
sb.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