常用的转义字符
\n 回车
\t 制表符
\b 退格
\r 按下回车键
windows系统中回车符其实是由两个符号组成的\r\n
linux中回车符是\n
函数
什么是函数
函数就是定义在类中的具有特定功能的一段独立小程序
函数也称为方法
定义函数的格式
修饰符 返回值类型 函数名(参数类型 形参2，参数类型 形参2，...) //函数名有多个单词时，第一个单词小写，后面的单词首字母大写
{
执行语句;
return 返回值;
}
特殊情况：
功能没有具体的返回值。 这时，retrun的后面直接用分号结束，因为没有具体值，所以不可以写具体的数据类型，
在java中只能用一个关键字void来表示这种情况。
注意：如果返回值类型为void，那么函数中的return语句可以省略不写。
特点：
1.定义函数可以将功能代码进行封装
2.便于对该功能进行服用
3.函数只有被调用才会被执行
4.函数的出现提高了代码的复用性
注意：
函数中只能调用函数，不能在函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交由调用者处理。
class FunctionDemo3
{
public static void main(String[] args)
{
System.out.println(add(4,5));
draw(7,9);
System.out.println(equals(5,6));
System.out.println(getMax(4,5));
}
/*
需求1：定义一个功能，完成两个整数的和的获取
思路：既然定义功能，就是可以用函数来体现
如何定义一个函数？
通过两个明确来完成
明确1：这个功能的结果是什么？ 是两个整数的和，是功能的结果，所以该功能的返回值类型是int
明确返回值的类型。
明确2：这个功能实现过程中是否需要未知内容参与运算？ 需要加数和被加数。
这就是函数的参数列表（参数的个数，参数的类型）
明确参数列表
注意：返回值类型和参数类型没有直接关系
*/
public static int add(int a,int b)
{
return a+b;
}
/*
需求2 定义一个功能，在控制台画一个矩形
明确1：这个功能的结果是什么？没有结果，直接打印到控制台
明确2：这个功能实现过程中是否需要未知内容参与运算？ 行和列不确定，需要两个整数int
*/
public static void draw(int row,int col)
{
for (int x=1;x<=row ;x++ )
{
for (int y=1;y<=col ;y++ )
{
System.out.print("*");
}
System.out.println();
}
}
/*
需求3 定义一个功能，比较两个数是否相等
明确1：这个功能的结果是什么？有结果，true或false,返回值为boolean
明确2：这个功能实现过程中是否需要未知内容参与运算？ 两个数不确定，需要两个整数int
*/
public static boolean equals(int a,int b)
{
/*
if(a==b)
return true;
else
return false;
*/
return a==b;//a==b,本身是在进行比较运算，结果是true或false，不要要是用(a==b)?true:false
}
/*
需求4 定义一个功能，获取两个整数中较大的那个数
明确1：这个功能的结果是什么？有结果，返回较大的整数
明确2：这个功能实现过程中是否需要未知内容参与运算？ 参与比较的数不确定，需要两个整数int
*/
public static int getMax(int a,int b)
{
return (a>b)?a:b;
}
}
函数的重载（overload）
重载的概念
在同一个类中，允许存在一个以上的同名名称，只要他们的参数个数或者参数类型不同即可。
重要特点
与返回值类型无关，只看参数列表
class FunctionDemo4
{
public static void main(String[] args)
{
System.out.println(add(1.2,2.5));
printCFB(5);
printCFB();
}
/*
函数的重载
1.同一个类
2.同名
3.参数个数不同或参数类型不同
4.函数重载和返回值类型无关
5.java是严谨性语言，如果函数出现调用的不确定性，会编译失败
*/
//加法运算，两个整数的和
public static int add(int a,int b)
{
return a+b;
}
//加法运算，两个小数的和
public static double add(double a,double b)
{
return a+b;
}
//加法运算，三个整数的和
public static int add(int a,int b,int c)
{
return a+b+c;
}
/*
打印乘法表
*/
public static void printCFB(int num)
{
for (int x=1;x<=num ;x++ )
{
for (int y=1; y<=x;y++ )
{
System.out.print(y+"*"+x+"="+y*x+"\t");//使用制表符'\t'能够实现输出时对齐
}
System.out.println();
}
}
/*
打印标准乘法表
*/
public static void printCFB()
{
printCFB(9);
}
}
数组(引用数据类型)
概念：同一种类型数据的结合，其实数组就是一个容器
数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素
格式1
元素类型[] 数组名=new 元素类型[元素个数或数组长度];
int[] arr=new int[5]
格式2
元素类型[] 数组名=new 元素类型[] {元素，元素，……};
int[] arr=new int[]{3,5,1,7};
int[] arr={3,5,1,7};
内存的划分
1.寄存器
2.本地方法区
3.方法区
4.栈内存
存储的都是局部变量（程序运行时，方法要进栈，否则，局部变量无法进栈）。
而且变量所属的作用域一旦结束，该变量就自动释放
5.堆内存
存储的是数组和对象（其实数组就是对象）；凡是new建立的，都在堆中
特点：
1.每一个实体都有首地址值
2.堆内存中的每个变量都有默认初始化值，根据类型的不同而不行（整数是0，小数是0.0或0.0f，boolean是false，char'\u0000'）
3.垃圾回收机制
arr不做任何实体指向，则arr=null；//数组arr为空，所有元素的值都为默认初始化值
int[] x=new int[3];//假设首地址为0x0034，数组内元素为x{0,0,0}
int[] y=new int[3];//假设首地址为0x0087，y{0,0,0}
x[0]=9;//x{9,9,9}
y[0]=34;//x{34,0,0}
x=y;//首地址变为0x0087，x{34,0,0}
多个数组变量可以指向同一个实体。
class ArrayDemo
{
public static void main(String[] args)
{
//元素类型[] 数组名=new 元素类型[元素个数或数组长度];
int[] arr=new int[3];
arr[0]=89;
System.out.println(arr[0]);
}
}
数组
数组的遍历
class ArrayDemo3
{
public static void main(String[] args)
{
/*
需要一个容器，但是不明确容器的具体数据
*/
//int[] arr=new int[3];
/*
需要一个容易，存储已知的具体数据
*/
//int[] arr=new int[]{89,34,270,17};
int[] arr={89,34,270,17}; //静态初始化方式
/*
对数组操作最基本的动作就是存和取
核心思想：就是对角标的操作。
*/
//数组的遍历
for (int i=0;i<arr.length ;i++ ) //arr.length，可以获取数组的长度
{
System.out.println("arr["+i+"]="+arr[i]+";");
}
}
}
获取数组中的最值
class ArrayDemo4
{
public static void main(String[] args)
{
int[] arr={-34,-19,-11,-109,-3,-56};
System.out.println("max="+getMax(arr));
System.out.println("max="+getMax_2(arr));
System.out.println("min="+getMin(arr));
}
/*
获取数组中的最大值
思路：
1.需要进行比较，并定义变量记录每次比较后较大的值
2.对数组中的元素进行遍历取出，和变量中记录的元素进行比较，
如果遍历到的元素大于变量中记录的元素，就用变量记录较大的值
3.遍历结束，该变量记录就是最大值
定义一个功能来实现：
明确1：结果
是数组中的元素，int型
明确2：未知内容
数组
*/
public static int getMax(int[] arr)
{
//定义变量记录较大值
int max=arr[0];
for (int i=1;i<arr.length ;i++ )
{
if(arr[i]>max)
max=arr[i];
}
return max;
}
public static int getMax_2(int[] arr)
{
//定义变量记录较大值
int maxelement=0;
for (int i=0;i<arr.length ;i++ )
{
if(arr[i]>arr[maxelement])
maxelement=i;
}
return arr[maxelement];
}
}
排序
选择排序
class SelectSort
{
public static void main(String[] args)
{
int[] arr={34,19,11,109,3,56};
getArr(arr);
selectSort(arr);
getArr(arr);
selectSort_2(arr);
getArr(arr);
}
/*
选择排序：
思路：
1.第一个元素与后边的所有元素比较，将最小值放在arr[0]，比较次数为arr.length-1
2.需要多轮排序，且每次的比较次数 -1
3.需要一个变量作为中转
4.返回排好序的数组
*/
public static void selectSort(int[] arr)
{
for (int i=0;i<arr.length-1 ;i++ ) //外循环中最多取到arr[arr.length-1]即可，此时就是arr[length-1]与arr[length]比较，比较之后结束
for (int j=i+1;j<arr.length ;j++ )
{
if (arr[i]>arr[j])
{
swap(arr,i,j);
}
}
}
/*
高效选择排序
使用变量记录角标，获得最小值角标之后，只进行一次交换，提高了效率
*/
public static void selectSort_2(int[] arr)
{
for (int i=0;i<arr.length-1 ;i++ )
{
int num=arr[i],index=i;
for (int j=i+1;j<arr.length ;j++ )
{
if (num>arr[j])
{
num=arr[j];
index=j;
}
}
swap(arr,i,index);
}
}
/*
遍历取出数组中的元素
*/
public static void getArr(int[] arr)
{
System.out.print("[");
for (int i=0;i<arr.length ;i++ )
{
if(i!=arr.length-1)
{
System.out.print(arr[i]+","); //使用System.out.print(arr[i]+',')，输出结果为47556378100109，而使用System.out.print(arr[i]+“,")则能正常输出3,11,19,34,56,109,
//解决：使用' '，在输出时强制转换为int型（int类型+char类型=int类型），而使用" "，int类型+string类型不能进行转化，只能在输出的数后边添加字符串
}
else
System.out.print(arr[i]);
}
System.out.print("]");
System.out.println();
}
/*
实现交换功能：实现arr[i]与arr[i+1]值的交换
*/
public static void swap(int[] arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
}
冒泡排序
class BubbleSort
{
public static void main(String[] args)
{
int[] arr={34,19,11,109,3,56};
getArr(arr);
bubbleSort(arr);
getArr(arr);
bubbleSort_2(arr);
getArr(arr);
}
/*
冒泡排序
1.相邻两个元素相比，较大的后移（下沉）
2.下一次比较比本次比较次数-1,且最后面的i个元素已排好序，不需要比较
3.总共需要排序arr.length-1次
4.内循环-1，为了避免角标越界；为了让外循环增加一次，内循环参数与比较的元素个数递减
*/
public static void bubbleSort(int[] arr)
{
for (int i=0;i<arr.length-1 ;i++)
{
for (int j=0;j<arr.length-1-i;j++ ) //外循环次数+1，则内循环需要比较次数-1
{
if (arr[j]>arr[j+1])
{
swap(arr,j,j+1);
//int temp;
//temp=arr[j];
//arr[j]=arr[j+1];
//arr[j+1]=temp;
}
}
}
}
/*
1.外循环从最后一个元素开始取值
2.外循环每次角标-1
3.内循环的比较次数随着外循环的变化而变化
*/
public static void bubbleSort_2(int[] arr)
{
for (int i=arr.length-1;i>0 ;i-- )
{
for (int j=0;j<i ;j++ )
{
if (arr[j]>arr[j+1])
{
swap(arr,j,j+1);
//int temp;
//temp=arr[j];
//arr[j]=arr[j+1];
//arr[j+1]=temp;
}
}
}
}
/*
遍历输出数组元素
*/
public static void getArr(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]);
}
System.out.print("]");
System.out.println();
}
/*
实现交换功能：实现arr[i]与arr[i+1]值的交换
*/
public static void swap(int[] arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
}
数组的查找
/*
面试题
给定一个有序的数组，如果往该数组中存储一个元素，并保证这个数组还是有序的，
那么这个元素的存储的角标如何获取
{13,15,19,20,33,45,78,106}
*/
import java.util.*;
class ArrayDemo5
{
public static void main(String[] args)
{
//int[] arr={4,1,5,7,3,8,2};
int[] arr={13,15,19,28,33,45,78,106};
//int index=getIndex(arr,50);
//System.out.println("index="+index);
int index1=halfSearch(arr,50);
System.out.println("index="+index1);
int index2=halfSearch_2(arr,50);
System.out.println("index="+index2);
int index3=Arrays.binarySearch(arr,50);//java中的折半查找
/*
如果存在，则返回的是具体的角标位置；不存在，则返回的是 -插入点-1。
*/
System.out.println("indxe="+index3);
}
/*
数组常见功能：查找。
1.确定需要查找的数组
2.确定需要查找的元素
需要两个形参
*/
public static int getIndex(int[] arr,int key)
{
for (int i=0;i<arr.length-1 ;i++ )
{
if (arr[i]==key)
{
return i;
}
}
return -1;
}
/*
折半查找（二分查找）
1.数组必须为有序数组
2.头角标和尾角标可能变化，故需要变量min，max
3.中间角标为mid=(min+max)/2
4.如果要查找的值key>arr[mid],则该值可能在后半部分，min+1；否则，可能在前半部分，max-1
5.当max<min时，停止查找，该数组中没有要查找的值key
*/
public static int halfSearch(int[] arr,int key)
{
int max,min,mid;
min=0;
max=arr.length-1;
mid=(min+max)/2;
while(key!=arr[mid])//当key==arr[mid]时，查找成功，停止查找
{
if (key>arr[mid])
min=mid+1;
else if (key<arr[mid])
max=mid-1;
if(max<min)
//return -1;//查找结束，该数组中不存在此元素
return min;//返回插入点
mid=(min+max)/2;
}
return mid;
}
public static int halfSearch_2(int[] arr,int key)
{
int max,min,mid;
min=0;
max=arr.length-1;
while(min<=max)//当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;//查找结束，该数组中不存在此元素
return min;//返回插入点
}
}
进制转换
class ArrayTest3
{
public static void main(String[] args)
{
toHex(60);
toBinary(6);
toOctal(8);
System.out.println(Integer.toBinaryString(6));//二进制转换
}
//十进制转十六进制
public static void toHex(int num)
{
trans(num,15,4);
}
//十进制转八进制
public static void toOctal(int num)
{
trans(num,7,3);
}
//十进制转二进制
public static void toBinary(int num)
{
trans(num,1,1);
}
public static void trans(int num,int base,int offset)
{
if(num==0)
{
System.out.println("0");
return ;//如果不写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;
}
printHex(arr,pos);
System.out.println();
}
public static void printHex(char[] arr,int pos)
{
for (int x=pos;x<=arr.length-1 ;x++ )
{
System.out.print(arr[x]);
}
}
}
二维数组
格式1：int[][] arr=new int[3][2];
定义了名称为arr的二维数组
二维数组中有3个以为数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0],arr[1],arr[2]
给第一个一维数组的1脚标位赋值78：arr[][1]=78;
格式2：int [][] arr=new int[3][];
分别对二维数组中的每一个小数组进行初始化：
arr[0]=new int[2];
arr[1]=new int[1];
arr[2]=new int[3];
格式3：
静态定义一个二维数组
int[][] arr={{3,1,7},{5,8,2,9},{4,1}};
/*
二维数组定义的格式
*/
class Array2Demo
{
public static void main(String[] args)
{
//int[] arr=new int[3];
//System.out.println(arr);//[I@bdb503，@左边是实体的类型，右边是实体的哈希值
//int[][] arr=new int[3][2];//创建一个二维数组，该数组中有3个一维数组，每个一维数组中有2个元素
//System.out.println(arr);//直接打印二维数组，[[I@bdb503，@左边有两个[，是二维数组
//System.out.println(arr[0]);//打印二维数组中脚标0的一维数组，@左边有1个[，是一维数组
//System.out.println(arr[0][0]);//打印二维数组中脚标0的一维数组中脚标为0的元素
//int[][] arr=new int[3][];
//System.out.println(arr);//直接打印二维数组，[[I@bdb503，@左边有两个[，是二维数组
//System.out.println(arr[0]);//一维数组未初始化，null
//System.out.println(arr[0][0]);//一维数组为初始化，一维数组中没有元素(不是元素为0)
//int[][] arr=new int[3][2];
//System.out.println(arr.length);//打印二维数组的长度，其实就是一位数组的个数
//System.out.println(arr[1].length);//打印脚标为1的一维数组的长度
/*
遍历二维数组
*/
int[][] arr={{3,1,7},{5,8,2,9},{4,1}};
int sum=0;
for (int x=0;x<arr.length ;x++ )
{
System.out.print("{");
for (int y=0;y<arr[x].length ;y++ )
{
if(y!=arr[x].length-1)
System.out.print(arr[x][y]+",");
else
System.out.print(arr[x][y]);
sum+=arr[x][y];
}
System.out.println("}");
}
System.out.println("sum="+sum);
}
}