JAVA快速排序

最新推荐文章于 2022-04-09 20:47:31 发布
最新推荐文章于 2022-04-09 20:47:31 发布
阅读量191 收藏
点赞数
分类专栏： JAVA基础知识 Java
原创版权归博主所有，未经授权禁止转载。
本文链接：https://blog.csdn.net/qq_36305530/article/details/81254956
版权

快速排序算法

快速排序（Quicksort）是对冒泡排序的一种改进。

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

递归方法的简述请见  我之前的博文JAVA函数（方法）

对快速排序算法的了解请见快速排序算法-百度百科

 

这个算法光是无法理解的，直接上代码，追踪每一步的运行，对照每一轮的结果去理解。

public class ArrQuickSort {
    public static void main(String[] args) {

	int[] arr = new int[] { 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 };
	printfArr(arr);
	System.out.println("=============================================================");
	arrQuickSort(arr, 0, arr.length - 1);
	System.out.println("=============================================================");
	printfArr(arr);
    }

    // 快速排序
    public static void arrQuickSort(int[] arr, int left, int right) {
	if (left < right) {
	    System.out.println("\n-------------------------------------------------------------");
	    System.out.print(String.format("arrQuickSort   left=%2d, right=%2d\t", left, right));
	    printfArr(arr);
	    System.out.print(
		    String.format("p=%d\tarr[%d]:%2d\tarr[%d]:%2d\n", left - 1, left, arr[left], right, arr[right]));
	    System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");

	    int p = partition(arr, left, right);
	    arrQuickSort(arr, left, p - 1);
	    System.out.println("左边快速排序完成,开始对右面排序...");
	    arrQuickSort(arr, p + 1, right);
	}
    }

    // 快速排序数组划分
    private static int partition(int[] arr, int left, int right) {
	int x = arr[right];
	int p = left - 1;
	for (int i = left; i < right; i++) {
	    System.out.print(String.format("partition      i=%2d, p=%2d\t\t", i, p));
	    printfArr(arr);
	    if (arr[i] <= x) {
		p++;
		swap(arr, p, i);
		System.out.print(String.format("arr[%d] <=>  arr[%d] , p=%2d\t\t", i, p, p));
	    } else {
		System.out.print("\t\t\t\t\t");
	    }
	    printfArr(arr);
	    System.out.println();
	}
	swap(arr, p + 1, right);
	System.out.print("partition      last :\t\t\t");
	printfArr(arr);
	return p + 1;
    }

    // 交换数组a中的a[i]和a[j]
    private static void swap(int[] arr, int i, int j) {
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
    }

    private static void printfArr(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] + " }");
	    }
	} // for
	System.out.println();
    }// void
}

运行结果如下：

{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }
=============================================================

-------------------------------------------------------------
arrQuickSort   left= 0, right=11	{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }
p=-1	arr[0]:24	arr[11]: 3
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

partition      i= 0, p=-1		{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }
					{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }

partition      i= 1, p=-1		{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }
					{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }

partition      i= 2, p=-1		{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }
					{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }

partition      i= 3, p=-1		{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }
					{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }

partition      i= 4, p=-1		{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }
					{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }

partition      i= 5, p=-1		{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }
					{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }

partition      i= 6, p=-1		{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }
					{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }

partition      i= 7, p=-1		{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }
					{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }

partition      i= 8, p=-1		{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }
					{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }

partition      i= 9, p=-1		{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }
					{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }

partition      i=10, p=-1		{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }
					{ 24, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 3 }

partition      last :			{ 3, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 24 }
左边快速排序完成,开始对右面排序...

-------------------------------------------------------------
arrQuickSort   left= 1, right=11	{ 3, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 24 }
p=0	arr[1]:43	arr[11]:24
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

partition      i= 1, p= 0		{ 3, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 24 }
					{ 3, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 24 }

partition      i= 2, p= 0		{ 3, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 24 }
					{ 3, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 24 }

partition      i= 3, p= 0		{ 3, 43, 35, 5, 93, 74, 25, 54, 84, 36, 66, 24 }
arr[3] <=>  arr[1] , p= 1		{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }

partition      i= 4, p= 1		{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }
					{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }

partition      i= 5, p= 1		{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }
					{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }

partition      i= 6, p= 1		{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }
					{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }

partition      i= 7, p= 1		{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }
					{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }

partition      i= 8, p= 1		{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }
					{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }

partition      i= 9, p= 1		{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }
					{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }

partition      i=10, p= 1		{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }
					{ 3, 5, 35, 43, 93, 74, 25, 54, 84, 36, 66, 24 }

partition      last :			{ 3, 5, 24, 43, 93, 74, 25, 54, 84, 36, 66, 35 }
左边快速排序完成,开始对右面排序...

-------------------------------------------------------------
arrQuickSort   left= 3, right=11	{ 3, 5, 24, 43, 93, 74, 25, 54, 84, 36, 66, 35 }
p=2	arr[3]:43	arr[11]:35
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

partition      i= 3, p= 2		{ 3, 5, 24, 43, 93, 74, 25, 54, 84, 36, 66, 35 }
					{ 3, 5, 24, 43, 93, 74, 25, 54, 84, 36, 66, 35 }

partition      i= 4, p= 2		{ 3, 5, 24, 43, 93, 74, 25, 54, 84, 36, 66, 35 }
					{ 3, 5, 24, 43, 93, 74, 25, 54, 84, 36, 66, 35 }

partition      i= 5, p= 2		{ 3, 5, 24, 43, 93, 74, 25, 54, 84, 36, 66, 35 }
					{ 3, 5, 24, 43, 93, 74, 25, 54, 84, 36, 66, 35 }

partition      i= 6, p= 2		{ 3, 5, 24, 43, 93, 74, 25, 54, 84, 36, 66, 35 }
arr[6] <=>  arr[3] , p= 3		{ 3, 5, 24, 25, 93, 74, 43, 54, 84, 36, 66, 35 }

partition      i= 7, p= 3		{ 3, 5, 24, 25, 93, 74, 43, 54, 84, 36, 66, 35 }
					{ 3, 5, 24, 25, 93, 74, 43, 54, 84, 36, 66, 35 }

partition      i= 8, p= 3		{ 3, 5, 24, 25, 93, 74, 43, 54, 84, 36, 66, 35 }
					{ 3, 5, 24, 25, 93, 74, 43, 54, 84, 36, 66, 35 }

partition      i= 9, p= 3		{ 3, 5, 24, 25, 93, 74, 43, 54, 84, 36, 66, 35 }
					{ 3, 5, 24, 25, 93, 74, 43, 54, 84, 36, 66, 35 }

partition      i=10, p= 3		{ 3, 5, 24, 25, 93, 74, 43, 54, 84, 36, 66, 35 }
					{ 3, 5, 24, 25, 93, 74, 43, 54, 84, 36, 66, 35 }

partition      last :			{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }
左边快速排序完成,开始对右面排序...

-------------------------------------------------------------
arrQuickSort   left= 5, right=11	{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }
p=4	arr[5]:74	arr[11]:93
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

partition      i= 5, p= 4		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }
arr[5] <=>  arr[5] , p= 5		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }

partition      i= 6, p= 5		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }
arr[6] <=>  arr[6] , p= 6		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }

partition      i= 7, p= 6		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }
arr[7] <=>  arr[7] , p= 7		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }

partition      i= 8, p= 7		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }
arr[8] <=>  arr[8] , p= 8		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }

partition      i= 9, p= 8		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }
arr[9] <=>  arr[9] , p= 9		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }

partition      i=10, p= 9		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }
arr[10] <=>  arr[10] , p=10		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }

partition      last :			{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }

-------------------------------------------------------------
arrQuickSort   left= 5, right=10	{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }
p=4	arr[5]:74	arr[10]:66
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

partition      i= 5, p= 4		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }
					{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }

partition      i= 6, p= 4		{ 3, 5, 24, 25, 35, 74, 43, 54, 84, 36, 66, 93 }
arr[6] <=>  arr[5] , p= 5		{ 3, 5, 24, 25, 35, 43, 74, 54, 84, 36, 66, 93 }

partition      i= 7, p= 5		{ 3, 5, 24, 25, 35, 43, 74, 54, 84, 36, 66, 93 }
arr[7] <=>  arr[6] , p= 6		{ 3, 5, 24, 25, 35, 43, 54, 74, 84, 36, 66, 93 }

partition      i= 8, p= 6		{ 3, 5, 24, 25, 35, 43, 54, 74, 84, 36, 66, 93 }
					{ 3, 5, 24, 25, 35, 43, 54, 74, 84, 36, 66, 93 }

partition      i= 9, p= 6		{ 3, 5, 24, 25, 35, 43, 54, 74, 84, 36, 66, 93 }
arr[9] <=>  arr[7] , p= 7		{ 3, 5, 24, 25, 35, 43, 54, 36, 84, 74, 66, 93 }

partition      last :			{ 3, 5, 24, 25, 35, 43, 54, 36, 66, 74, 84, 93 }

-------------------------------------------------------------
arrQuickSort   left= 5, right= 7	{ 3, 5, 24, 25, 35, 43, 54, 36, 66, 74, 84, 93 }
p=4	arr[5]:43	arr[7]:36
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

partition      i= 5, p= 4		{ 3, 5, 24, 25, 35, 43, 54, 36, 66, 74, 84, 93 }
					{ 3, 5, 24, 25, 35, 43, 54, 36, 66, 74, 84, 93 }

partition      i= 6, p= 4		{ 3, 5, 24, 25, 35, 43, 54, 36, 66, 74, 84, 93 }
					{ 3, 5, 24, 25, 35, 43, 54, 36, 66, 74, 84, 93 }

partition      last :			{ 3, 5, 24, 25, 35, 36, 54, 43, 66, 74, 84, 93 }
左边快速排序完成,开始对右面排序...

-------------------------------------------------------------
arrQuickSort   left= 6, right= 7	{ 3, 5, 24, 25, 35, 36, 54, 43, 66, 74, 84, 93 }
p=5	arr[6]:54	arr[7]:43
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

partition      i= 6, p= 5		{ 3, 5, 24, 25, 35, 36, 54, 43, 66, 74, 84, 93 }
					{ 3, 5, 24, 25, 35, 36, 54, 43, 66, 74, 84, 93 }

partition      last :			{ 3, 5, 24, 25, 35, 36, 43, 54, 66, 74, 84, 93 }
左边快速排序完成,开始对右面排序...
左边快速排序完成,开始对右面排序...

-------------------------------------------------------------
arrQuickSort   left= 9, right=10	{ 3, 5, 24, 25, 35, 36, 43, 54, 66, 74, 84, 93 }
p=8	arr[9]:74	arr[10]:84
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

partition      i= 9, p= 8		{ 3, 5, 24, 25, 35, 36, 43, 54, 66, 74, 84, 93 }
arr[9] <=>  arr[9] , p= 9		{ 3, 5, 24, 25, 35, 36, 43, 54, 66, 74, 84, 93 }

partition      last :			{ 3, 5, 24, 25, 35, 36, 43, 54, 66, 74, 84, 93 }
左边快速排序完成,开始对右面排序...
左边快速排序完成,开始对右面排序...
=============================================================
{ 3, 5, 24, 25, 35, 36, 43, 54, 66, 74, 84, 93 }

运行结果里面写的还算是比较清除的，有啥问题可以评论留言。

漠诽
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java快速排序工具类
07-16
使用泛型的对象排序工具类（使用算法：快速排序），适合初学者学习快速排序的基本原理和实现。
Java 算法：快速排序
抛弃幻想，准备斗争
04-22 170
以数组为例，从大到小排序。 分析例子： 思想： 1.先找到第一个元素为基点，此时第一个元素为4，将它放入此元素排序好的位置去： 2.接着将小于4的部分与大于4的部分，依旧进行快速排序。 如何将4这个元素移到正确的位置上呢？进一步分析： 我们对这一过程称为子过程（Partition）： j：分界点。 i：当前访问的元素 当元素e>v的话，直接放在>...
快速排序【Java实现】
码农翻身的博客
07-02 722
public static void main(String[] args) { int arr[] = {60,30,70,90,50,10,40,80}; System.out.println("排序前："+ Arrays.toString(arr)); quickSort(arr,0,arr.length-1); } /* * 左标记的作用是找到一个比基准值pivot大的数字 * 右标记的作用是找到一个比基...
快速排序Java实现
charlong的博客
02-29 544
快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 快速排序算法通过多次比较和交换来实现排序，其排序流程如下： (1)首先设定一个分界值，通过该分界值将数组分成左右两部分...
Java快速排序
weixin_51985152的博客
04-09 1万+
快速排序是基于二分的思想，对冒泡排序的一种改进。主要思想是确立一个基数，将小于基数的数放到基数左边，大于基数的数字放到基数的右边，然后在对这两部分进一步排序，从而实现对数组的排序 优点 效率高：时间复杂度平均为O(N*logN)，顾名思义，最快的排序算法；耗费资源少：最优的情况下空间复杂度为：O(logn) ，每一次都平分数组的情况；代码较为简单。 缺点 不稳定，初始序列有序或基本有序时，时间复杂度降为O(n^2)。 图解 有一个无序数组，首先确认一个基数，一般都以第0个元素为基数，然后定义左右指针，我们
java快速排序
weixin_39902962的博客
03-24 2万+
Java算法——java快速排序 文章目录Java算法——java快速排序一、快速排序简介二、代码实现三、测试用例总结 一、快速排序简介 示例数组： int[] arr = {-9, 78, 0, 0, 1, 0, 3, -1, 23, -56, 7} 简介：快速排序，基于冒泡排序移动换位思想——通过遍历，判断每个数并放置在数组合适的位置。思路如下： 选定一个基准值pivot（通常指定为数组第一个值），比基准值大的放在右侧，比基准值小的放在左侧 指定左右两个指针分别为left，right ；left &l
浅析java快速排序算法
09-03
主要介绍了浅析java快速排序算法,需要的朋友可以参考下
java快速排序算法和案例
最新发布
01-23
java快速排序算法和案例
java 快速排序
01-08
private static void sort(Integer[] array) { for (int i = 0; i ; i++) { int temp = i; for (int j = i + 1; j ; j++) { if(array[j][temp]){ temp = j; } } exchange(array, i ,... }
Java 快速排序
11-21
用Java对整型一维数组实现快速排序，pivot值默认为数组第一个值。
JAVA函数（方法）
热门推荐
[email protected]的博客
07-26 4万+
函数的概念： 函数是定义在类中的一段独立的代码块，用来实现某个功能。Java中，函数又被称为方法。 函数的主要作用是为了提高代码的复用性。 函数都是在栈内存中运行；运行的函数处在栈顶。 函数格式：修饰符 返回值类型 函数名 （ [ 参数类型1 参数名1,参数类型2 参数名2.... ] ）{ // [ ] ...
Java 多态理解
[email protected]的博客
08-11 9766
多态：同样的引用调用同样的方法却做了不同的事情。 概述： 在设计一个方法时，通常希望该方法具备定的通用性。 例如要实现一个动物叫的方法，由于每种动物的叫声是不同的，因此可以在方法中接收一个动物类型的参数，当传入猫类对象时就发出猫类的叫声，传人犬类对象时就发出犬类的叫声。在同一个方法中，这种由于参数类型不同而导致执行效果各异的现象就是多态。 在Java中为了实现多态，允许使用一个父类类型的变...
JAVA基础思维导图
[email protected]的博客
08-11 2638
思维导图 源文件想要的可以评论留邮箱，看到后会给你们发过去。
JAVA语言的组成（一：JAVA关键字、JAVA标识符）
[email protected]的博客
07-25 2443
Java关键字又叫保留字，对Java的编译器有特殊的意义。 Java关键字都是由小写字母组成，关键字 的用法和写法都是固定的。 用于定义数据类型的关键字 class void interface   boolean byte short int long float double           用...
JAVA面向对象（概念，类与对象，封装）
[email protected]的博客
07-30 1887
理解什么是面向对象之前先理解一下什么是面向过程。   面向过程   过程就是一件事情的先后经过；从什么开始到什么介绍，有一个时间上的先后顺序。 程序过程就体现在代码执行的先后顺序。 面向过程，就是一种解决问题的思路。用这种思想解决问题时，我们关心的是一件事情的先后经过，现经过什么，后再做什么。 在面向过程的编程中，将一个问题划分成多个子功能组成，最后依次调用。用这种编程思想编程时，流...
JAVA面向对象（继承）
[email protected]的博客
08-01 1247
继承 在Java中，类的继承是指在一个现有类的基础上构建一个新的类，构建出来的新类被称作子类，现有的类被称作父类，子类会自动地拥有父类所有可继承的属性和方法。 子类继承自父类，父类派生子类。 class Person { String name; // 声明一个Person类,有成员方法speak()和walk() public void speak() { S...
Apache ftpserver 最大登录数
[email protected]的博客
09-27 860
Apache ftpserver 最多只能登录数 10 个用户问题 日志： Currently 1 out of 10 users logged in
JAVA语言的组成（二：JAVA变量类型、JAVA运算符）
[email protected]的博客
07-25 639
Java 中基本的数据类型有8中，数值型4种（byte，short，int，long），字符型1种（char），浮点型2种（float，double）,布尔型1种（boolean）。 类型名 占用空间 取值范围   类型名 占用空间 取值范围 byte 8位（1字节） -128~127 char 16位（2字节） 0~6553...
JAVA一维数组
[email protected]的博客
07-26 495
数组的定义： 在Java中，数组是指一组数据的集合。 在数组中能存放任意类型的元素，但同一个数组里面的元素类型必须一致。 格式：数据类型[ ]    数组名  =  new    数据类型[  数组容量  ] ；        （推荐这种写法）    或     数据类型  数组名[ ]    =  new    数据类型[  数组容量  ] ； 示例： public class T...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

漠诽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值