JAVA基础应用总结

最新推荐文章于 2022-03-09 11:12:52 发布

大盼

最新推荐文章于 2022-03-09 11:12:52 发布

阅读量626

点赞数

文章标签：冒泡排序二进制转换

本文链接：https://blog.csdn.net/a254830856/article/details/22927995

版权

应用程序总结

1. 遍历

遍历思想：依次输出区间内的元素

代码示例：

/**
遍历
需求：输出0~4之间的数
*/
class Traversal//遍历 
{
	public static void main(String[] args) 
	{
		for (int i = 0;i<4 ;i++ )
		{
			System.out.println("i="+i);
		}
	}
}

2. 累加

累加思想：遍历数组中的元素，求和

代码示例：

/**
累加思想
需求：求1~1000的和
*/
class Add 
{
	public static void main(String[] args) 
	{
		int a = 0;
		for (int i = 0;i<=1000 ;i++ )//遍历1~1000中的所有整数
		{
			a+=i;//累加
		}
		System.out.println("a="+a);
	}
}

3. 计数器

计数器思想：遍历过程中所遍历的次数

代码示例：

/**
计数器思想的应用
求出1～100之间，即使3又是7的倍数出现的次数？
分析：
遍历1~100之间的任意整数x，找到满足x%3=0&x%7=0的数时，计数器count++
*/

class  Counter
{
	public static void main(String[] args) 
	{	
		int count = 0;
		for (int x = 1;x<=100 ;x++ )
		{
			if (x%3==0&x%7==0)
			{
				count++;//计数器思想
			}
		}
		System.out.println("count="+count);
	}
}

4. 求最值

求数组中的最大值或者最小值

代码示例：

/**
获取最值
需求：求一个数组中的最值
分析：
遍历数组中的元素，
将最值存储入a[min]中，
返回a[min]
*/

class Min
{
	public static void main(String[] args) 
	{
		int[] a = new int[]{1,23,14,31,15,66,75,11};
		int x = getMin(a);
		System.out.println("max="+x);
	}
	public static int getMin(int[] a)
	{
		int min = 0;//此变量用来存储最值
		for (int i = 1;i<a.length ;i++ )//遍历数组中的元素
		{
			/*
			如果将min和其他元素比较，将会出错，因为min = 0,比所有值都小，这时如果求最小值，结果将会是0；
			将min当做角标来使用可以避免这一问题发生。
			*/
			if (a[min]>a[i])
			{
				a[min] = a[i];
			}
		}
		return a[min];
	}
}<span style="font-size:14px;">
</span>

5. 排序

5.1选择排序

选择排序思想：从0角标位开始，取元素依次和其后面的元素进行比较，如果符合排序标准，不做任何操作，否则将这两个元素互换位置，一轮执行完毕后，最值出现在0角标位位置

图例：

代码示例：

class  SelectionSort
{
	public static void main(String[] args) 
	{
		int[] arr = new int[]{5,11,3,34,7,80,9,65,64,43};
		printArray(arr);//排序前
		selectionSort(arr);//排序
		printArray(arr);//排序后
	}
	public static void selectionSort(int[] arr)//选择排序
	{
		for (int i = 0;i<arr.length-1 ;i++ )
		{
			for (int x = i+1;x<arr.length;x++ )//i+1是为了避免重复和相同的元素比较，
			{
				if (arr[i]>arr[x])
				{
					//互换位置
					int temp = arr[x];
					arr[x] = arr[i];
					arr[i] = temp;
				}
			}
		}
	}
	public static void printArray(int[] arr)//打印数组
	{
		for (int i =0;i<arr.length ;i++ )
		{
			if (i!=arr.length-1)
			{
				System.out.print(arr[i]+",");
			}else
			{
				System.out.print(arr[i]+"\n");
			}
			
		}
	}
}

5.2冒泡排序

冒泡排序思想：相邻两个元素进行比较，符合排序标准不进行任何操作，否则，将这两个元素进行位置互换，执行完毕后，最值将被移动到最后角标位

图例：

代码示例：

class  BubbleSort
{
	public static void main(String[] args) 
	{
		int[] arr = new int[]{5,11,3,34,7,80,9,65,64,43};
		bubbleSort(arr);
		printArray(arr);
	}
	public static void bubbleSort(int[] arr)
	{
		for (int x =0;x<arr.length-1 ;x++ )
		{
			for (int y = 0;y<arr.length-x-1 ;y++ )//-x为了减去已经比较过的元素的重复比较，-1为了防止角标越界
			{
				if (arr[y]<arr[y+1])
				{
					int temp = arr[y+1];
					arr[y+1] = arr[y];
					arr[y] = temp;
				}
			}
		}
	}
	public static void printArray(int[] arr)//打印数组
	{
		for (int i =0;i<arr.length ;i++ )
		{
			if (i!=arr.length-1)
			{
				System.out.print(arr[i]+",");
			}else
			{
				System.out.print(arr[i]+"\n");
			}
			
		}
	}
}

6. 查找

6.1一般查找

原理：如果数组中元素的值等于要找的数，那么这个元素就是要找的数

class  Find
{
	public static void main(String[] args) 
	{
		int[] arr = new int[]{5,11,3,34,7,80,9,65,64,43};
		int a = find(arr,80);
		System.out.println("a="+a);
	}
	public static int find(int[] arr,int key)
	{	
		int i = 0;
		for (;i<arr.length ;i++ )
		{
			if (key == arr[i])
			{
				return i;
			}
		}
		return -1;//返回-1时，表明要查找的元素在数组中不存在
	}
}

6.2折半查找（有序数组）

折半查找的前提：要查找的数组必须是有序数组；

折半查找的原理：用要查找的数直接和数组的中间角标位mid开始比较，如果这个元素大于要找的数，那么就在mid~arr.length这个角标位范围内找，如果小于要找的数，那么就在数组0~mid这个角标位范围内找，如果要找的数==arr[mid]，直接输出即可；重复以上循环，直到找到为止。

图示：

代码示例：

/**
折半查找原理：（前提：数组有序）
从数组的中间角标位开始查询，如果这个key大于中间角标的元素，
那么在这个中间角标位后面的元素中查询，以此类推，直到查到要找的元素为止
*/
class  HalfSearch
{
	public static void main(String[] args) 
	{
		int[] arr = new int[]{1,3,5,7,9,11,13,15,17};
		int a = halfSearch(arr,90);
		System.out.println("a="+a);
	}
	public static int halfSearch(int[] arr,int key)
	{
		int min =0,max = arr.length-1,mid = (min+max)/2;
		while (key!=arr[mid])
		{
			if (key <arr[mid])//当要找的元素大于中间角标的元素，那么从min到max-1这个范围查找
			{
				max = mid -1;
			}else
				if (key>arr[mid])
				{
					min =mid +1;
				}
			if (min > max)//此时这个元素不存在
			{
				return -1;
			}
			mid =(min+max)/2;
		}
		return mid;

	}
}

7. 进制转换

进制转换的三种方法
1,使用算术运算符%和/进行转换

通常情况下我们都使用第一种方法，来进行进制转换，除基数取模运算

代码示例：

class  ToBin1
{
	public static void main(String[] args) 
	{
		toBin(8);
	}
	public static void toBin(int a)
	{
		StringBuffer sb = new StringBuffer();
		int num = 0;
		while (a >0)
		{
			num = a%2;
			a = a/2;
			sb.append(num);
		}
		System.out.println(sb.reverse());//反转
	}
}

2,使用位运算符&和>>>进行转换

思想：一个数的二进制数，&基数base，右移进制位数offset，即可得到转换后的进制数

图示：

代码示例：

class ToHex
{
	public static void main(String[] args) 
	{
		toHex(60);
	}
	
	/*
	十进制-->十六进制。
	*/
	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'));//如果temp是12,12-10=2,2+'A'(65)=67,char(67) = 'C'
			else
				sb.append(temp);

			num  = num >>> 4;
		}
		System.out.println(sb.reverse());

	}

3,使用查表法进行转换

思路：

1，建立一个char类型的数组chs，存储进制中所出现的字符
2，定义一个char类型的数组arr，用来存储查找到的字符，该数组的大小为32；
3，定义一个指针pos，其值是角标的最后一位，让元素从数组的最后一位开始存储
4，去除0的特殊情况
5，转换数
5.1将数值num & 上基数base来获取其基数为的值
5.2将获取到的基数位的值，当做角标位来查找数组chs中对应的元素并存入新的数组arr中
5.3移位offset，取下一个基数位所对应的值
6，从pos指向的位打印新数组中存储的元素

代码示例：

/**
进制转换
*/
class TransNum
{
	public static void main(String[] args) 
	{
		toBin(-6);
		line();
		toHex(-60);
		line();
		toBa(60);
	}

	/*
	十进制-->二进制
	*/
	public static void toBin(int num)//二进制的基数是1，进制位数是1
	{
		trans(num,1,1);
	}
	/*
	十进制-->八进制
	*/
	public static void toBa(int num)
	{
		trans(num,7,3);//八进制的基数是7，进制位数3
	}
	/*
	十进制-->十六进制
	*/
	public static void toHex(int num)//十六进制的基数是15，进制位数是4
	{
		trans(num,15,4);
	}
	//三个未知参数，分别是：1，要转换的数num 2，与上的基数base 3，右移的位数offset
	public static void trans(int num,int base,int offset)
	{

		if(num==0)//排除了，所有0的进制都为0这一情况
		{
			System.out.println(0);
			return ;
		}
		char[] chs = {'0','1','2','3'//建立一个char类型的数组chs，存储进制中所出现的字符
				,'4','5','6','7'
				,'8','9','A','B'
				,'C','D','E','F'};
		char[] arr = new char[32];//定义一个char类型的数组arr，用来存储查找到的字符，该数组的大小为32；

		int pos = arr.length;//定义一个指针pos，其值是角标的最后一位，让元素从数组的最后一位开始存储

		while(num!=0)
		{
			int temp = num & base;//任意一个二进制数，&上它的基数，都能获取其二进制数
			arr[--pos] = chs[temp];//将取到的数，存入数组arr中；因为实际可存储位是arr.length-1位，所以使用--pos
			num = num >>> offset;//移位offset，取下一个基数位所对应的值；考虑到有负数的情况，使用无符号右移>>>
		}

		for(int x=pos; x<arr.length; x++)
		{
			System.out.print(arr[x]);
		}
	}
	public static void line()//换行
	{
		System.out.println();
	}
}

总结：第一种和第二种方法，无法对负数的十进制进行转换，第三种方法可以

8. 嵌套for循环

打印99乘法表

/**
嵌套循环的应用，
打印99乘法表
外循环控制行，内循环控制列
*/
class  Table
{
	public static void main(String[] args) 
	{
		for (int x = 1;x<=9 ;x++ )
		{
			for (int y = 1;y<=x ;y++ )//尖朝上；for(int y =x; y<=9;y++) 尖朝下
			{
				System.out.print(x+"*"+y+"="+x*y+"\t");
			}
			System.out.println();
		}
	}
}

输出结果：

总结：

在嵌套循环中，外循环控制行运行次数，内循环控制列的运行次数

且内循环for (int y = 1;y<=x ;y++ )时，输出尖朝上

内循环for(int y =x; y<=9;y++) 尖朝下

大盼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础应用总结

应用程序总结1. 遍历遍历思想：依次输出区间内的元素代码示例：/**遍历需求：输出0~4之间的数*/class Traversal//遍历 { public static void main(String[] args) { for (int i = 0;i<4 ;i++ ) { System.out.println("i="+i); } }
复制链接

扫一扫