基础知识以及数组

最新推荐文章于 2024-05-15 23:59:17 发布

语言表达一切

最新推荐文章于 2024-05-15 23:59:17 发布

阅读量436

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/wanghuitao666/article/details/41038231

版权

java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

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]+",");
else
System.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]+",");
else
System.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("* ");
				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<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]+", ");
	else
	System.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'));
			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<arr.length; x++)
	{
	System.out.print(arr[x]);
	}
	System.out.println();
	}
	
	
	
	public static void main(String[] args) {
		
		toBinary(-10);
		toOctal(20);
		toHex(60);
		

	}

}

语言表达一切

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
基础知识以及数组

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------数组的定义：就是一个容器，是引用类型，是数组是相同类型数据的集合如int[] x其中，int是存放的数据类型，x是数组类型数组的好处：自动给数组中的元素编号数组的特点：1.长度固定，一旦被创建它的长度就是丌可改发的；2.其元素类型必须是相同类型，不允许出现混合类型；3.数
复制链接

扫一扫