2 Java语言基础组成_如何在 java 中表现一个数组呢？两种表现形式-CSDN博客

本文链接：https://blog.csdn.net/jingruoas/article/details/50223777

Java语言基础组成：

关键字：就是被Java赋予了特殊含义的单词

标识符：在程序中自定义的一些名称（数字不可以开头不可以使用关键字）

注释：用于注解说明解释程序的文字就是注释。（单行注释、多行注释、文档注释）

常量和变量：常量：常量表示不能改变的值。整数进制：二进制八进制十进制十六进制进制的转换十进制转二进制：十进制进行除2运算二进制转十进制：二进制进行乘2运算。

变量：内存中的一个存储区域，将不确定的数据进行存储。什么时候定义变量？只要是数据不确定的时候，就定义变量。

运算符：1）、算术运算符。  + - * / % % +:连接符。 ++,-- 2）、赋值运算符。 = += -= *= /= %= 3）、比较运算符。   特点：该运算符的特点是：运算完的结果，要么是true，要么是false。 4）、逻辑运算符。
& | ^ ! && ||  逻辑运算符除了 ! 外都是用于连接两个boolean类型表达式。 &: 只有两边都为true结果是true。否则就是false。 |:只要两边都为false结果是false，否则就是true ^:异或：和或有点不一样。
两边结果一样，就为false。两边结果不一样，就为true. & 和 &&区别： & ：无论左边结果是什么，右边都参与运算。   &&:短路与，如果左边为false，那么右边不参数与运算。 | 和|| 区别：|：两边都运算。
||：短路或，如果左边为true，那么右边不参与运算。 5）、位运算符:用于操作二进制位的运算符。

语句：1.选择结构
1.if语句
A. 格式: if(条件表达式){
语句组 }
B. 语法: 满足条件表达式，执行语句组
2.if-else语句
A. 格式:if(条件表达式){
语句组1 }

else{
语句组2 }
B. 语法: 满足条件表达式，执行语句组1，否则执行语句组2 }
3.if-else-if语句
A. 格式:if(条件表达式1){
语句组1
}

else if(条件表达式1){
语句组2

}

else{

语句组3 }
B. 语法: 满足条件表达式1，执行语句组1，否则查看是否满足条件表达式2，如果满足，执行语句组2，否则执行语句组3

4.switch语句
A. 格式:switch(表达式){ //表达式只能是byte，short，int，char类型的数据
case 常量1: 表达式1; break;

case 常量2: 表达式2; break;

case 常量3: 表达式3; break;

default : 表达式4 }
B. 语法:拿表达式的值和常量的值相比较，如果相同，则执行对应的表达式，如果都不相同，则执行default后面的表达式

2.循环结构
1.while语句
A. 格式: while(布尔表达式){
语句组 }
B. 语法: 布尔表达式为真，则执行语句组

2.do-while语句
A. 格式: do{
语句组
}

while(布尔表达式);
B. 语法: 先执行语句组，再判断布尔表达式，如果布尔表达式为真，则继续执行语句组，否则，结束循环语句

3.for语句
A. 格式: for（初始化表达式;条件表达式;迭代语句）{
语句组
}
B. 语法: 先执行初始化表达式，再判断条件表达式是否为真，如果为真，执行语句组，然后执行迭代语句，然后再执行条件表达式，直到条件表达式为假跳出循环。

break跳出循环体，continue跳出本次循环进入下次循环。

函数：为了提高代码的复用性，可以将其定义成一个单独的功能，该功能的体现就是java中的函数。函数就是体现之一。

java中的函数的定义格式：修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数1，„){ 执行语句； return 返回值； } 当函数没有具体的返回值时，返回的返回值类型用void关键字表示。
如果函数的返回值类型是void时，return语句可以省略不写的，系统会帮你自动加上。 return的作用：结束函数。结束功能。
如何定义一个函数？
函数其实就是一个功能，定义函数就是实现功能，通过两个明确来完成： 1）、明确该功能的运算完的结果，其实是在明确这个函数的返回值类型。 2）、在实现该功能的过程中是否有未知内容参与了运算，其实就是在明确这个函数的参数列表(参数类型&参数个数)。

函数的作用： 1）、用于定义功能。 2）、用于封装代码提高代码的复用性。注意：函数中只能调用函数，不能定义函数。主函数： 1）、保证该类的独立运行。 2）、因为它是程序的入口。 3）、因为它在被jvm调用。

重载的定义是：在一个类中，如果出现了两个或者两个以上的同名函数，只要它们的参数的个数，或者参数的类型不同，即可称之为该函数重载了。
如何区分重载：当函数同名时，只看参数列表。和返回值类型没关系

数组：用于存储同一类型数据的一个容器。好处：可以对该容器中的数据进行编号，从0开始。数组用于封装数据，就是一个具体的实体。
如何在java中表现一个数组呢？两种表现形式。 1）、元素类型【】变量名 = new 元素类型【元素的个数】； 2）、元素类型【】变量名 = {元素1，元素2...}；元素类型【】变量名 = new 元素类型【】{元素1，元素2...}；

程序举例

1 循环语句

class sanjiao
{
public static void main(String[] args)
{
for (int x=0;x<5;x++ )
{
for (int y=x+1;y<5;y++ )
{
System.out.print(" ");
}
for (int z=0;z<=x;z++ )
{
System.out.print("* ");
}
System.out.println();
}

}
}

2 综合小程序

class Function
{
public static void main(String[] args)
{
int x=getResult(4);
System.out.println("x="+x);
Get(4);
int y=getSum();
System.out.println("y="+y);
int sum=Sum(4,6);
System.out.println("sum="+sum);
boolean b=compare(3,4);
System.out.println("b="+b);
int a=getMax(3,9);
System.out.println("a="+a);
draw(3,5);
printHr();
draw(4,7);
printHr();
draw(5,3);
printHr();
print99();
}

//一个数乘以3加5
public static int getResult (int num)
{
return num*3+5;
}

public static void Get (int sum)
{
System.out.println(sum*3+5);
}
//两个数求和
public static int getSum ()
{
return 3+4;
}

public static int Sum (int x,int y)
{
return x+y;
}

//比较两个数大小
public static boolean compare (int a,int b)
{
/*if (a==b)
return true;
else
return false;*/

return (a==b)?true:false;
//return a==b;
}

//比较两个数大小取最大值
public static int getMax (int a,int b)
{
if(a>b)
return a;
else
return b;
//return (a>b)?a:b;
}

//打印矩形
public static void draw (int a,int b)
{
for(int x=0;x<a;x++)

{
for(int y=0;y<b;y++)
System.out.print("*");
System.out.println();
}
}
public static void printHr ()
{
System.out.println("-----------------------");
}

//打印 99乘法表
public static void print99 ()
{

for (int x=1;x<=9 ;x++ )
{
for (int y=1;y<=x ;y++ )
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}

}
}

3 进制转换

class jinzhi
{
public static void main(String[] args)
{
//System.out.println(" ");
tobin(6);
tohex(60);
}
//十进制转换为十六进制
public static void tohex(int num)
{
/*int n1=num&15;
n1-10+'a'
int temp=num>>>4;
temp&15;*/
//StringBuffer sb=new StringBuffer();
for (int x=0;x<8 ;x++ )
{
int temp=num&15;
if(temp>9)
System.out.println((char)(temp-10+'A'));
//sb.append((char)(temp-10+'A'));
else
System.out.println(temp);
// sb.append(temp);
num=num>>>4;
}
//System.out.println(sb.reverse());
}
/*
十进制转换为二进制
*/
public static void tobin(int num)
{
StringBuffer sb=new StringBuffer();
while(num>0)
{
//System.out.println(num%2);

sb.append(num%2);
num=num/2;
}
System.out.println(sb.reverse());
}

}

class shuzu3
{
public static void main(String[] args)
{
//tohex(60);
//toBin(-6);
tobin1(6);
to8(17);
tohex1(60);
}
/*
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的结果肯定在15之内那结果直接与表对应
就可以找到对应的元素：比-10+A简单查表法
表：通过数组的形式来定义
出结果但是是反着的用已经学过的容器数组来存储
*/
public static void tohex(int num)
{
//定义十六进制表
char[] chs={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
//定义一个临时容器
char[] arr= new char[8];
int pos=arr.length;
while(num!=0)
//for (int x=0;x<8 ;x++ )
{
int temp=num & 15;
System.out.println(chs[temp]);
arr[--pos]=chs[temp];
num=num>>>4;
}
System.out.println("pos="+pos);
//数据存储arr遍历
for (int x=pos;x<arr.length ;x++ )
{
System.out.print(arr[x]+",");
}
}
/* public static void toBin(int num)
{
//定义二进制表
char[] chs={'0','1'};
//定义一个临时容器
char[] arr= new char[32];
//定义一个操作数组的指针
int pos=arr.length;
while(num!=0)
{
int temp=num & 1;
arr[--pos]=chs[temp];
num=num>>>1;
}
System.out.println("pos="+pos);
//数据存储arr遍历
for (int x=pos;x<arr.length ;x++ )
{
System.out.print(arr[x]);
}

}*/
//进制转换优化

//十进制转二进制

public static void tobin1(int num)
{
trans(num,1,1);
}
//十进制转八进制
public static void to8(int num)
{
trans(num,7,3);
}

//十进制转十六进制
public static void tohex1(int num)
{
trans(num,15,4);
}

public static void trans(int num,int base,int 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.println(arr[x]);
}
}

}

4 排序

class shuzu1
{
public static void main(String[] args)
{
int[] arr={4,5,6,3,1,2,7,9};
//排序前
printArray(arr);
//排序
//selectsort(arr);
bubblesort(arr);
//排序后
printArray(arr);

//Arrays.sort(arr);//java中已经定义好的一种排序方式，实际开发中对数组排序要使用这种方法
}
/*对数组进行排序
选择排序：内循环结束后最值出现在头角标位置上
冒泡排序：最值出现在最后
嵌套循环
*/
public static void selectsort(int[] arr)
{
for (int x=0;x<arr.length-1 ;x++ )
{
for (int y=x+1;y<arr.length ;y++ )
{
if (arr[x]>arr[y])
{
/*int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;*/
swap(arr,x,y);
}
}
}
}
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 bubblesort(int[] arr)
{
for (int x=0;x<arr.length ;x++ )
{
for (int y=0;y<arr.length-x-1 ;y++ )//-x让每一次比较的元素减少，-1避免角标越界
{
if (arr[y]>arr[y+1])
{
/*int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
*/
swap(arr,y,y+1);
}
}

}
}
/*发现无论什么排序都需要对满足条件的元素进行位置置换
所以可以把这部分代码提取出来，单独封装成一个函数*/
public static void swap(int[] arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}

}
5 获取

class shuzu2
{
public static void main(String[] args)
{
//int[] arr={3,2,1,6,4,9};
//int index=getIndex(arr,9);
//System.out.println("index="+index);
int[] arr={3,4,5,6,7,9};
// int index=halfsearch(arr,13);
// int index=halfsearch_2(arr,13);
//System.out.println("index="+index);
int index=getIndex_2(arr,2);
System.out.println("index="+index);

}
/*折半查找前提数组是有序数组

*/
public static int halfsearch(int[] arr,int key)
{
int min,max,mid;
min=0;
max=arr.length-1;
mid=(max+min)/2;

while(arr[mid]!=key)
{
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
if(min>max)
return -1;
mid=(max+min)/2;
}
return mid;
}
//折半的第二种方式
public static int halfsearch_2(int[] arr,int key)
{
int min=0,max=arr.length-1,mid;
while(min<=max)
{
mid=(max+min)>>1;
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
else
return mid;

}
return -1;
}

//定义功能获取key第一次出现在数组中的位置如果返回是-1，你们该key在数组中不存在
public static int getIndex(int[] arr,int key)
{
for (int x=0;x<arr.length ;x++ )
{
if(arr[x]==key)
return x;
}
return -1;
}
//有一个有序的数组，需要将一个元素插入到数组中还要保证数组是有序的
//如何获取该元素在数组中的位置换到最后min就是要的位置
public static int getIndex_2(int[] arr,int key)
{
int min=0,max=arr.length-1,mid;
while(min<=max)
{
mid=(max+min)>>1;
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
else
return mid;

}
return min;
}
}

//二分查找法。必须有前提：数组中的元素要有序。

6 获取最值

class shuzu
{
public static void main(String[] args)
{
int[] arr={5,2,5,5,6,7,8,9};
int max=getMax(arr);
System.out.println("max="+max);
int max1=getMax_2(arr);
System.out.println("max1="+max);
boolean[] ar =new boolean[3];
System.out.println(ar[0]);
int min=getMin(arr);
System.out.println("min="+min);
double[] arr1=new double[]{3.2,5.6,7.8,9.8};
double max2=getMax(arr1);
System.out.println("max2="+max2);
}
/*获取数组中最大最小值
获取最大值，比较，每一次比较都会有较大的值，通过变量进行临时存储
让每个元素进行比较，记录较大值，都比较完成，该变量就是最大值
定义变量，初始化为数组中任意一个元素即可
通过循环语句进行遍历
最大值赋值给变量
定义功能
1明确结果最大元素int
2未知内容一个数组 int【】*/
public static int getMax(int[] arr)
{
int max =arr[0];
for (int x=1;x<arr.length ;x++ )
{

if(arr[x]>max)
max= arr[x];
}
return max;
}
/*获取最大值的另一种方式
把max初始化为0可不可以？可以这种原理是在初始化为数组中任意一个角标
*/
public static int getMax_2(int[] arr)
{
int max =0;
for (int x=1;x<arr.length ;x++ )
{

if(arr[x]>arr[max])
max= x;
}
return arr[max];
}
/*获取数组中最小值
*/
public static int getMin(int[] arr)
{
int min=0;
for (int x=1;x<arr.length ;x++ )
{
if (arr[x]<arr[min])
{
min=x;
}

}
return arr[min];
}
//获取double类型数组最大值，因为功能一致，所以函数名称一致，以重载形式存在
public static double getMax(double[] arr1)
{
double max=arr1[0];
for (int x=1;x<arr1.length ;x++ )
{
if (arr1[x]>max)
{
max=arr1[x];
}
}
return max;
}

}