Java中数组的操作集和类——Arrays

最新推荐文章于 2024-03-27 11:18:47 发布
最新推荐文章于 2024-03-27 11:18:47 发布
阅读量117 收藏
点赞数
分类专栏： 从零到入职 文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43589736/article/details/112061904
版权

Java中数组的操作类Arrays

Arrays类中的方法主要是一些方法的重载，即通过传入参数的不同达到操作不同数组的目的。
经整理，主要是以下六个方法
在这里插入图片描述

这里补充一下，sort是升序排序，而且二分排序必须是排好序的数组才能进行操作。

二分查找

package demo1;

import java.awt.RadialGradientPaint;
import java.util.Scanner;

public class demo1 {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		System.out.println("请任意输入一个长度以及一个该长度递增的数组");
		int x = sc.nextInt();
		int st[] = new int[x];

		for (int i = 0; i < x; i++) {
			st[i] = sc.nextInt();
		}
		System.out.println("请输入要查找的数");

		int taget = sc.nextInt();
		x = binarySearch(st, taget, 0, st.length);
		System.out.println(x);
	}

	public static int binarySearch(int arr[], int taget, int start, int end) {
		if (end == start) {
			return -1;
		}

		int middle = (start + end) / 2;

		if (arr[middle] == taget) {
			return middle;
		} else if (arr[middle] < taget) {
			return binarySearch(arr, taget, middle, end);
		} else {
			return binarySearch(arr, taget, 0, middle);
		}
	}

}

在这里插入图片描述
冒泡排序

package demo1;

import java.util.Scanner;
import java.util.Arrays;

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

		Scanner sc = new Scanner(System.in);
		System.out.println("请输入数组长度");
		int len = sc.nextInt();
		int[] arr = new int[len];
		int taget;
		for (int i = 0; i < arr.length; i++) {
			arr[i] = sc.nextInt();
		}

		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] < arr[j + 1]) { // 从大到小，从小到大：arr[j]>arr[j+1]
					taget = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = taget;
				} else
					continue;
			}
		}

		for (int i : arr) {
			System.out.println(i);
		}

	}
}

选择排序

package demo1;

import java.util.Scanner;

public class demo3 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入数组长度");
		int len = sc.nextInt();
		int[] arr = new int[len];

		for (int i = 0; i < arr.length; i++) {
			arr[i] = sc.nextInt();
		}

		for (int i = 0; i < arr.length - 1; i++) {
			int maxIndex = 0;
			for (int j = 1; j < arr.length - i; j++) { //因为maxIndex已经定义为0，所以元素从1开始，也跟第一个比较
				if (arr[maxIndex] < arr[j]) {
					maxIndex = j;
				}
			}
			
			//最大的数放在末尾，与末尾交换
			int taget = arr[maxIndex];
			arr[maxIndex] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = taget;

		}

		for (int p : arr) {
			System.out.println(p);
		}
	}
}

插入排序

package demo1;

import java.util.Scanner;

public class demo4 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		System.out.println("请输入需要排序的元素的个数");
		int k = sc.nextInt();

		int[] arr = new int[k];

		for (int i = 0; i < arr.length; i++) {
			arr[i] = sc.nextInt();
		}

		int i;
		int j;
		for (i = 1; i < arr.length; i++) {
			int tmp = arr[i];
			for (j = i - 1; j >= 0; j--) {
				if (arr[j] > tmp) {
					arr[j + 1] = arr[j];
				} else {
					break;
				}
			}
			arr[j + 1] = tmp;
		}

		for (int a : arr) {
			System.out.println(a);
		}

	}

}

快速排序

package demo1;

import java.util.Scanner;

public class demo05 {
	public static void main(String[] args) {
		System.out.println("请输入一个数组长度:");
		Scanner sc = new Scanner(System.in);
		int len = sc.nextInt();
		int arr[] = new int[len];
		System.out.println("请输入数组元素");
		for (int i = 0; i < len; i++) {
			arr[i] = sc.nextInt();
		}

		Sort(arr, 0, arr.length - 1);

		for (int i : arr) {
			System.out.println(i);
		}
	}

	public static void Sort(int arr[], int star, int end) {
		if (star < end) {
			int index = quickSort(arr, star, end);

			quickSort(arr, star, index - 1);
			quickSort(arr, index + 1, end);
		}
	}

	public static int quickSort(int arr[], int star, int end) {
		int target = arr[star];
		int i = star;
		int j = end;
		while (i < j) {
			while (i < j && arr[j] >= target) {
				j--;
			}
			if (i < j) {
				arr[i] = arr[j];
				i++;
			}

			while (i < j && arr[i] < target) {
				i++;
			}
			if (i < j) {
				arr[j] = arr[i];
				j--;
			}
		}
		arr[i] = target;
		return i;
	}
}

当然会有一些代码会把quickSort里面的if的判断丢掉，只写里面的的语句，这里建议加上为好。

当然还有另外一种递归调用方法。

package demo1;

import java.util.Scanner;

public class demo5 {
	public static void main(String[] args) {
		System.out.println("请输入一个数组长度:");
		Scanner sc = new Scanner(System.in);
		int len = sc.nextInt();
		int arr[] = new int[len];
		System.out.println("请输入数组元素");
		for (int i = 0; i < len; i++) {
			arr[i] = sc.nextInt();
		}

		quickSort(arr, 0, arr.length - 1);

		for (int i : arr) {
			System.out.println(i);
		}
	}

	public static void quickSort(int arr[], int star, int end) {
		if (star < end) {
			int target = arr[star];
			int i = star;
			int j = end;
			while (i < j) {
				while (i < j && arr[j] >= target) {
					j--;
				}
				if (i < j) {
					arr[i] = arr[j];
					i++;
				}

				while (i < j && arr[i] < target) {
					i++;
				}
				if (i < j) {
					arr[j] = arr[i];
					j--;
				}
			}
			arr[i] = target;
			
			quickSort(arr, star, i - 1);
			quickSort(arr, i + 1, end);
		}
	}
}

这两种方法都是正确的。

计数排序
不利用大小判断的排序方法–计数排序

package demo1;

import java.util.Scanner;
import java.util.Map;
import java.util.HashMap;

public class demo6 {
	public static void main(String[] args) {
		System.out.println("请输入一个数组长度:");
		Scanner sc = new Scanner(System.in);
		int len = sc.nextInt();
		int arr[] = new int[len];
		System.out.println("请输入数组元素");
		for (int i = 0; i < len; i++) {
			arr[i] = sc.nextInt();
		}

		countSort(arr);

		for (int i : arr) {
			System.out.println(i);
		}
	}

	public static Map<String, Integer> data(int arr[]) {
		Map<String, Integer> map = new HashMap<String, Integer>();

		int max = Integer.MIN_VALUE;
		int min = Integer.MAX_VALUE;

		for (int i = 0; i < arr.length; i++) {
			if (max < arr[i]) {
				max = arr[i];
			}

			if (min > arr[i]) {
				min = arr[i];
			}
		}

		map.put("max", max);
		map.put("min", min);

		return map;
	}

	public static void countSort(int arr[]) {
		Map<String, Integer> map = data(arr);
		int max = map.get("max");
		int min = map.get("min");

		int count[] = new int[max - min + 1];

		for (int i = 0; i < arr.length; i++) {
			count[arr[i] - min]++;
		}

		int index = 0;
		for (int i = 0; i < count.length; i++) {
			while (count[i] > 0) {
				arr[index++] = i + min;
				count[i]--;
			}
		}
	}
}

计数排序的另一种写法，自己参悟一下。

package demo1;

import java.util.Scanner;
import java.util.Map;
import java.util.HashMap;

public class demo06 {
	public static void main(String[] args) {
		System.out.println("请输入一个数组长度:");
		Scanner sc = new Scanner(System.in);
		int len = sc.nextInt();
		int arr[] = new int[len];
		System.out.println("请输入数组元素");
		for (int i = 0; i < len; i++) {
			arr[i] = sc.nextInt();
		}

		countSort(arr);
		
	}

	public static Map<String, Integer> data(int arr[]) {
		Map<String, Integer> map = new HashMap<String, Integer>();

		int max = Integer.MIN_VALUE;
		int min = Integer.MAX_VALUE;

		for (int i = 0; i < arr.length; i++) {
			if (max < arr[i]) {
				max = arr[i];
			}

			if (min > arr[i]) {
				min = arr[i];
			}
		}

		map.put("max", max);
		map.put("min", min);

		return map;
	}

	public static void countSort(int arr[]) {
		Map<String, Integer> map = data(arr);
		int max = map.get("max");
		int min = map.get("min");

		int count[] = new int[max - min + 1];
		int result[] = new int[arr.length];

		for (int i = 0; i < arr.length; i++) {
			count[arr[i] - min]++;
		}

		for (int i = 1; i < count.length; i++) {
			count[i] = count[i] + count[i - 1];
		}

		for (int i = 0; i < arr.length; i++) {
			result[count[arr[i] - min] - 1] = arr[i];
		}

		for (int i : result) {
			System.out.println(i);
		}
	}
}
J-ADan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA基础(三十九)——常用类之Arrays类
qq_37466661的博客
09-14 643
java Arrays
Java Arrays的常用操作总结
rqz__的博客
04-02 492
Java Arrays是Java语言中的一个数组类，它提供了一系列的方法用于操作数组。Arrays类包含了排序、搜索、复制、比较、填充等方法，这些方法可以使操作数组更加简单高效。它拥有很多静态方法，可以方便地对数组进行各种操作，比如查找最大值、最小值等。Arrays还支持多维数组，并且可以用于基本数据类型与对象类型数组的操作。
Java中的数组（Array）
weixin_58545784的博客
02-06 3179
数组(array)是一种用于存储多个相同类型数据的存储模型第一种：数据类型[] 数组名int[] arr;char[] arr;第二种：数据类型 数组名[]int arr[];char arr[];
Java数组的详解
挨踢星球
06-29 2427
数组(Array)是Java中的一种引用数据类型，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
Java中数组的定义和使用
最新发布
XU_very_NB的博客
03-27 1306
数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。1.2数组的创建及初始化数组的创建：格式如下T[] 数组名 = new T[N];T：表示数组中存放元素的类型T[]：表示数组的类型N：表示数组的长度// 创建一个可以容纳10个int类型元素的数组// 创建一个可以容纳5个double类型元素的数组// 创建一个可以容纳3个字符串元素的数组数组的初始化：数组的初始化主要分为动态初始化以及静态初始化。1.动态初始化：在创建数组时，直接指定数组中元素的个数2.
java数组排序
09-04
在Java编程语言中，数组排序是一项基础且重要的任务。它涉及到不同的算法，这些算法通过比较和交换元素来达到数组元素的有序状态。本篇将详细探讨几种常见的排序算法及其在Java中的实现。 首先，让我们从最简单的...
Java Arrays.sort和Collections.sort排序实现原理解析
08-25
Java中的`Arrays.sort()`和`Collections.sort()`是两个常用的排序函数，它们分别用于对数组和集合进行排序。这两个函数在内部实现上有所不同，但都基于高效的排序算法。 首先，`Collections.sort()`方法在处理列表...
java String[]字符串数组自动排序的简单实现
09-01
首先，我们需要了解Java中用于排序的主要工具——`Arrays`类。`Arrays`类是Java `util`包的一部分，提供了多种对数组操作的方法，其中包括排序方法`sort()`。在给定的代码示例中，我们看到`Arrays.sort(str)`被用来...
Java数据结构和算法之Java数组
03-14
总的来说，Java数组是学习数据结构和算法的基础，理解其工作原理和相关操作对于提高编程能力至关重要。通过深入学习数组，你可以更好地应对各种编程挑战，为更复杂的数据结构和算法打下坚实的基础。在实际开发中，...
java——基础程序设计
03-08
Java 中的 Arrays 语法是 Java 语言中用来操作数组的语法。Arrays 语法包括数组的排序、数组的转换为字符串等。 Arrays.sort() 方法是 Java 语言中用来排序数组的方法。例如，int[] arr = {23, 43, 34, 2, 5, -4, ...
操作java数组的常用工具类
05-27
操作java数组的常用工具类 和大家共享一下 共同学习
数组工具JAVA类
05-11
java的数组操作类
Java基础——Arrays类
qq_52519008的博客
05-08 5995
每日正能量 如果你要做一件事，不要到处宣言自己的想法，只管安安静静地去做，值不值，时间是最好的证明，自己的人生，得自己负责。 Arrays类 JDK中提供了一个专门用于操作数组的工具类，即Arrays类，位于java util 中。 用前需导包：import java.util.Arrays; 1. Arrays类常用方法 返回类型 方法 说明 String toString（array） 将数组array转换成字符串 void s...
Java中数组的基本操作
梦里有阳光
12-08 3000
二维数组赋初值的时候，数组长度可以不一致，int[3][],表示存3个1维数组，但是每个1维数组长度不一定相等。二维数组中，数组的长度代表数组中一维数组的个数，第二个数则代表一维数组中存放元素的个数。1、声明一个数组，需要在声明时指定长度，并且通过new来完成数组对象创建操作。删，数组长度由于在初始化声明时已经固定了，所以没有办法删除数组中的元素。2、数组不能直接打印输出，直接打印输出的结果是数组在内存中的地址。4、 输出数组中的单个元素，可以使用下标，注意下标从0开始。改，更新数组元素的值。
Java数组常用操作
Lilip_的博客
04-19 7639
 1.数组长度  2.数组填充  3.数组复制  4.数组比较  5.数组排序  6.在数组中搜索指定元素  7.把数组转换成字符串 数组的常用操作包括数组的充、复制、比较、排序等。Java提供了相应对数组的操作的系统函数（方法），利用系统函数（方法）可以对数组进行各种操作。 1、数组长度 数组长度指的是数组的大小，也就是数组包含元素的个数。如果想获得数组的长度，可以用其本身的 length 属性获得。使用方法就是在数组名后加 “.length”。代码如下： public class Main
Java中的常用类Arrays
m0_67474817的博客
03-17 841
Arrays 操作数组的工具类（静态工厂） Arrays.toString(arr1)//static String toString(int[] a) 返回指定数组内容的字符串表示形式。 Arrays.equals(arr1,arr2)//static boolean equals(int[] a, int[] a2) 如果两个指定的int数组彼此 相等 ，则返回 true Arrays.equals(arr1,1,3,arr2,1,3)//static boolean equals(int[] a
Java：数组工具类Arrays类的常用方法的用法及代码
xuehyunyu的博客
08-04 1万+
Arrays类是JDK提供的专门用于操作数组的工具类，位于java.util包中。 用Arrays类的方法操作数组，无需自己编码。 Arrays类的常用方法： 1、boolean equals(array1,array2)：比较两个数组是否相等。 package com.jredu.ch06; import java.util.Arrays; public class Ch03 {
java定义数组的三种类型
热门推荐
瓜爪牛的博客
11-16 3万+
三种定义数组的格式如下：int[] arr1=new int[10]; int[] arr2={1,2,3,6}; int[] arr3=new int[]{1,2,3,4,5,6,7,22}; 注意：数组的length是一个属性，而字符串的length()是一个方法了！！！虽然都是求的他们各自的长度package array; public class Array { publi
java 数组 集合类_Java中的数组与集合
weixin_30844577的博客
02-12 305
一、数组如何区分数组和其他集合类呢？其实有两种方式可以区分开：效率和类型。在java中，数组是一个简单的先行序列，它使得元素的访问速度非常快，但付出的代价是--创建一个数组对象时，他的大小是固定的，而且不可在那个数组对象的“存在时间”内发生改变(也就是只能容纳一种类型的对象)。有关数组越界问题？在java中，无论使用的是数组还是集合，都会进行范围检查---若超过边界，就会获得一个RuntimeEx...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值