使用for循环输出杨辉三角

1.技术要点：

两侧数值都是1，triangle[0][0]、triangle[i][0]、triangle[i][i]的元素值为1。
其他位置的数值是其正上方的数值与左上角数值之和，triangle[i][j]=triangle[i-1][j]+triangle[i-1][j-1]。

2.代码：

//创建二维数组
int triangle[][]=new int[10][];
//遍历二维数组的第一层
for(int i=0;i<triangle.length;i++){
	//初始化第二层数组的大小
	triangle[i]=new int[i+1];
	//遍历第二层数组
	for(int j=0;j<=i;j++){
		if(i==0||j==0||j==i){
			//将两侧的数组元素赋值为1
			triangle[i][j]=1;
		}else{
			//其他数值通过公式计算
			triangle[i][j]=triangle[i-1][j]+triangle[i-1][j-1];
		}
		//输出数组元素
		System.out.print(triangle[i][j]+"\t");
	}
	//换行
	System.out.println();
}

3.效果：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1

For循环输出九九乘法表

1.技术要点：
第一层for循环，称为外循环，用于控制表格的行。
第二层for循环，称为内循环，用于控制表格的列。

2.代码：

//循环控制变量从1遍历到9
		for(int i=1;i<=9;i++){
			//第二层循环控制变量与第一层最大索引相等
			for(int j=1;j<=i;j++){
				//输出计算结果但不换行
				System.out.print(j+"*"+i+"="+i*j+"\t");				
			}
			//在外层循环中换行
			System.out.println();
		}

3.效果：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

for循环输出空心的菱形

1.代码：
public static void main(String[] args) {
//输出7行的菱形
printHollowRhomus(7);
}

public static void printHollowRhomus(int size){
	if(size % 2==0){
		//计算菱形大小
		size++;
	}
	for(int i=0;i<size/2+1;i++){
		for(int j=size/2+1;j>i+1;j--){
			//输出左上角位置的空白
			System.out.print("  ");
		}
		for(int j=0;j<2*i+1;j++){
			if(j==0||j==2*i){
				//输出菱形上半部边缘
				System.out.print("* ");
			}else{
				//输出菱形上半部空心
				System.out.print("  ");
			}
		}
		//换行
		System.out.println("");
	}
	
	for(int i=size/2+1;i<size;i++){
		for(int j=0;j<i-size/2;j++){
			//输出菱形左下角空白
			System.out.print("  ");
		}
		for(int j=0;j<2*size-1-2*i;j++){
			if(j==0||j==2*(size-i-1)){
				//输出菱形下半部边缘
				System.out.print("* ");
			}else{
				//输出菱形下半部空心
				System.out.print("  ");
			}
		}
		//换行
		System.out.println("");
	}
}

2.效果：

实现两个变量的互换（不借助第3个变量）

	//创建扫描器
	Scanner scan =new Scanner(System.in);
	System.out.println("请输入变量A的值");
	//接收第一个变量值
	long A =scan.nextLong();
	System.out.println("请输入变量B的值");
	//接收第二个变量值
	long B=scan.nextLong();
	System.out.println("A="+A+"\tB="+B);
	System.out.println("执行变量互换。。。");
	//执行变量互换
	A=A^B;
	B=B^A;
	A=A^B;
	System.out.println("A="+A+"\tB="+B);

不用乘法运算符实现2×16

//创建输入流扫描器
Scanner scan= new Scanner(System.in);
System.out.println("请输入一个整数：");
//获取输入的整数
long number =scan.nextLong();
System.out.println("你输入的数字是："+number);
System.out.println("该数字乘以2的运算结果为："+(number<<1));
System.out.println("该数字乘以4的运算结果为："+(number<<2));
System.out.println("该数字乘以8的运算结果为："+(number<<3));
System.out.println("该数字乘以16的运算结果为："+(number<<4));

数组排序

Array.sort()方法

使用Array.sort()方法对数组排序

冒泡排序法

int[] arr={63,4,24,1,3,13};
		for(int i=1;i<arr.length;i++){
			//比较相邻两个元素，较大的数往后冒泡
			for(int j=0;j<arr.length-i;j++){
				if(arr[j]>arr[j+1]){
					//把第一个元素值保存到临时变量中
					int temp=arr[j];
					//把第二个元素值保存到第一个元素单元中
					arr[j]=arr[j+1];
					//把临时变量也就是第一个元素原值保存到第二个元素中
					arr[j+1]=temp;
				}
				System.out.print(arr[j]+"  ");
			}
		System.out.print("[");
		for(int j=arr.length-i;j<arr.length;j++){
			System.out.print(arr[j]+" ");
		}
		System.out.print("]\n");
		}

直接插入法

int[] arr={20,40,90,30,80,70,50};
		//定义临时变量
		int temp;
		int j;
		for(int i=1;i<arr.length;i++){
			//保存临时变量
			temp=arr[i];
			for(j=i-1;j>=0&&arr[j]>temp;j--){
				//数组元素交换
				arr[j+1]=arr[j];
			}
			//在排序位置插入数据
			arr[j+1]=temp;
		}
		System.out.print("");
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}

快速排序法

技术要点：
对冒泡排序的一种改进，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据小，然后再按此方法对这两部分数据分别进行快速排序。

public static void main(String[] args) {
		int[] arr={49,38,65,97,76,13,27,49};
		quickSort(arr,0,arr.length-1);
 
	}
	public static void quickSort(int sortarray[],int lowIndex,int highIndex){
		//记录最小索引
		int lo=lowIndex;
		//记录最大索引
		int hi=highIndex;
		//记录分界点元素
		int mid;
		if(highIndex>lowIndex){
			//确定中间分界点元素值
			mid=sortarray[(lowIndex+highIndex)/2];
			while(lo<=hi){
				while((lo<highIndex)&&(sortarray[lo]<mid)){
					//确定不大于分界元素值的最小索引
					++lo;
				}
				while((hi>lowIndex)&&(sortarray[hi]>mid)){
					//确定大于分界元素值的最大索引
					--hi;
				}
				//如果最小索引与最大索引没有重叠
				if(lo<=hi){
					//交换两个索引的元素
					swap(sortarray,lo,hi);
					//递增最小索引
					++lo;
					//递减最大索引
					--hi;
				}
			}
			//递归排序没有未分界元素
			if(lowIndex<hi){
				quickSort(sortarray,lowIndex,hi);
			}
			//递归排序没有未分界元素
			if(lo<highIndex){
				quickSort(sortarray,lo,highIndex);
			}
		}
	}
	
	public static void swap(int swapArray[],int i,int j){
		//交换数组元素
		int temp=swapArray[i];
		swapArray[i]=swapArray[j];
		swapArray[j]=temp;
		for(int k=0;k<swapArray.length;k++){
			System.out.print(swapArray[k]+" ");
		}
		System.out.println("\t");
	}

选择排序法

技术要点：
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后。

int[] arr={63,4,24,1,3,15};
		int index;
		for(int i=1;i<arr.length;i++){
			 index=0;
				for(int j=1;j<=arr.length-i;j++){
					if(arr[j]>arr[index]){
						//查找最大值
						index=j;
					}
				}
				//交换在arr.length-i和index（最大值）位置的两个数
				int temp=arr[arr.length-i];
				arr[arr.length-i]=arr[index];
				arr[index]=temp;
		}
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}

将二维数组中的行列互换

public static void main(String[] args) {
		//创建二维数组
		int arr[][]=new int[][]{{1,2,3},{4,5,6},{7,8,9}};
		System.out.println("行列互调前： ");
		//输出二维数组
		printArray(arr);
		int arr2[][]=new int[arr.length][arr.length];
		//调整数组行列数组
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr[i].length;j++){
				arr2[i][j]=arr[j][i];
			}
		}
		System.out.println("行列互调后： ");
		//输出行列互调后的二维数组
		printArray(arr2);
		}
 
	private static void printArray(int[][] arr) {
		//遍历数组
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr.length;j++){
				//不换行输出数组元素
				System.out.print(arr[i][j]+"");
			}
			//换行
			System.out.println();
			
		}
	}