Java基础——数组
一、数组的概念
1.数组的定义
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。
数组的四个基本特点：
1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2.其元素的类型必须是相同类型，不允许出现混合类型。
3.数组类型可以是任何数据类型，包括基本类型和引用类型。
4.数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java 中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。
2.数组的创建和初始化
2.1数组的声明方式(以一维数组为例)：
type[ ] arr_name; //方式一（推荐使用这种方式）
type arr_name[ ]; //方式二
注：1.声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM 才分配空间，这时才与长度有关。2.声明一个数组的时候并没有数组真正被创建。3.构造一个数组，必须指定长度。
2.2创建基本类型的一维数组：
public class Test {
public static void main(String args[ ]) {
int[ ] s = null; // 声明数组；
s = new int[10]; // 给数组分配空间；
for (int i = 0; i < 10; i++) {
s[i] = 2 * i + 1;//给数组元素赋值； 数组是对象，数组中的元素就是对象的属性
System.out.println(s[i]);
}
}
}内存图：
2.3初始化：
数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化：
静态初始化：除了用 new 关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
int [ ] a = { 1, 2, 3 };// 静态初始化基本类型数组；
Man[ ] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；
动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行。
int[ ] a1 = new int[2];//动态初始化数组，先分配空间；
a1[0]=1;//给数组元素赋值；
a1[1]=2;//给数组元素赋值；
数组的默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
int a2[ ] = new int[2]; // 默认值：0,0
boolean[ ] b = new boolean[2]; // 默认值：false,false
String[ ] s = new String[2]; // 默认值：null, null
二、数组常见操作
数组创建后，我们经常需要对数组做两种最常见的操作：遍历、拷贝。
遍历指的就是“通过循环遍历数组的所有元素”。
拷贝指的是将某个数组的内容拷贝到另一个数组中。 实质上，容器的扩容本质上就是“数组的拷贝”。
1.数组的遍历
数组元素下标的合法区间：[0, length-1]。可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。
示例：使用循环初始化和遍历数组
package cn.pxy.test;
public class Test {
public static void main(String[] args) {
int[] a=new int[4];
//初始化数组元素的值
for(int i=0;i<a.length;i++) {
a[i]=100*i;
}
//获取元素的值
for(int i=0;i<a.length;i++) {
System.out.println(a[i]);
}
}
}运行结果：
2.for-each 循环
增强 for 循环 for-each 是 JDK1.5 新增加的功能，专门用于读取数组或集合中所有的元素，即对数组进行遍历。for-each 增强 for 循环在遍历数组过程中不能修改数组中某元素的值。for-each 仅适用于遍历，不涉及有关索引（下标）的操作。
例如：使用增强 for 循环遍历数组for-each 循环。
package cn.pxy.test;
public class Test {
public static void main(String[] args) {
String[] s= {"aa","bb","cc","dd"};
for(String temp:s) {
System.out.println(temp);
}
}
}运行结果：
3.数组的拷贝
System 类里也包含了一个 static void arraycopy（object src，int srcpos，object dest， int destpos，int length）方法，该方法可以将 src 数组里的元素值赋给 dest 数组的元素，其中 srcpos 指定从 src 数组的第几个元素开始赋值，length 参数指定将 src 数组的多少个元素赋给 dest 数组的元素。
示例：
package cn.pxy.test;
public class Test {
public static void main(String[] args) {
String[] s= {"aa","bb","cc","dd"};
String[] sCopy=new String[6];
System.arraycopy(s, 0, sCopy, 0, s.length);
for(int i=0;i<sCopy.length;i++) {
System.out.print(sCopy[i]+"\t");
}
}
}运行结果：
4.java.util.Arrays 类
JDK 提供的 java.util.Arrays 类，包含了常用的数组操作，方便我们日常开发。Arrays类包含了：排序、查找、填充、打印内容等常见的操作。
例如：使用 Arrays 类输出数组中的元素：
package cn.pxy.test;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] a= {1,2};
System.out.println(a);//打印数组引用的值
System.out.println(Arrays.toString(a));//打印数组元素的值
}
}运行结果：
示例：使用 Arrays 类对数组元素进行排序：
package cn.pxy.test;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] a= {1,2,33,44,88,99,66,77};
System.out.println(Arrays.toString(a));//打印数组元素的值
Arrays.sort(a);
System.out.println(Arrays.toString(a));//排序后
}
}运行结果：
示例：使用 Arrays 类实现二分法查找法：
package cn.pxy.test;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] a= {1,2,33,44,88,99,66,77};
System.out.println(Arrays.toString(a));//打印数组元素的值
Arrays.sort(a);//使用二分法查找，必须先对数组排序
System.out.println(Arrays.toString(a));//排序后
//返回排序后新的索引位置，若未能找到返回负数
System.out.println("该元素的索引："+Arrays.binarySearch(a, 66));
}
}运行结果：
示例：使用Arrays类对数组进行填充：
package cn.pxy.test;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] a= {1,2,33,44,88,99,66,77};
System.out.println(Arrays.toString(a));//打印数组元素的值
Arrays.fill(a, 2,4,100);//将2到4索引的元素替换为100
System.out.println(Arrays.toString(a));
}
}运行结果：
5.Comparable 接口
想对某个类的对象之间做比较，就需要实现 Comparable 接口。接口中只有一个方法compareTo，这个方法定义了对象之间的比较规则。 依据这个“比较规则”，我们就能对所有对象实现排序。
事实上，java 中排序算法的底层也依赖 Comparable 接口。Comparable 接口中只有一个方法：public int compareTo(Object obj) obj 为要比较的对象。
方法中，将当前对象和 obj 这个对象进行比较，如果大于返回 1，等于返回 0，小于返回-1. (此处的 1 也可以是正整数，-1 也可以是负整数)。
三、多维数组
1.多维数组
多维数组可以看成以数组为元素的数组。可以有二维、三维、甚至更多维数组，但是实际开发中用的非常少，最多到二维数组。
示例：二维数组的声明：
public class Test {
public static void main(String[ ] args) {
// Java中多维数组的声明和初始化应按从低维到高维的顺序进行
int[ ][ ] a = new int[3][ ];
a[0] = new int[2];
a[1] = new int[4];
a[2] = new int[3];
// int a1[ ][ ]=new int[ ][4];//非法
}
}二维数组的静态初始化：
public class Test {
public static void main(String[ ] args) {
int[ ][ ] a = { { 1, 2, 3 }, { 3, 4 }, { 3, 5, 6, 7 } };
System.out.println(a[2][3]);
}
}内存分配：
二维数组的动态初始化：
import java.util.Arrays;
public class Test {
public static void main(String[ ] args) {
int[ ][ ] a = new int[3][ ];
// a[0] = {1,2,5}; //错误，没有声明类型就初始化
a[0] = new int[ ] { 1, 2 };
a[1] = new int[ ] { 2, 2 };
a[2] = new int[ ] { 2, 2, 3, 4 };
System.out.println(a[2][3]);
System.out.println(Arrays.toString(a[0]));
System.out.println(Arrays.toString(a[1]));
System.out.println(Arrays.toString(a[2]));
}
}运行结果：
获取数组长度：
package cn.pxy.test;
public class Test {
public static void main(String[] args) {
int[][] a= {{1,2,3},{3,4},{3,5,6,7},{7,8,9,10}};
//获取的二维数组第一维数组的长度
System.out.println(a.length);
//获取第二维第一个数组长度
System.out.println(a[0].length);
}
}运行方式：
2.数组存储表格数据
表格数据模型是计算机世界最普遍的模型，可以这么说，大家在互联网上看到的所有数据本质上都是“表格”，无非是表格之间互相套用。如下表格是一张雇员表：
ID | 姓名 | 年龄 | 职位 | 入职时间 |
1001 | 张三 | 20 | 前台 | 2019-07-06 |
1002 | 李四 | 19 | 总监 | 2020-07-01 |
1003 | 胖咸鱼 | 18 | 程序员 | 2021-07-09 |
我们观察表格，发现每一行可以使用一个一维数组存储：
Object[ ] a1 = {1001,"张三",20,"前台","2019-07-06"};
Object[ ] a2 = {1002,"李四",19,"总监","2020-07-01"};
Object[ ] a3 = {1003,"胖咸鱼",18,"程序员","2021-07-09"};
此处基本数据类型”1001”，本质不是 Object 对象。JAVA 编译器会自动把基本数据类型“自动装箱”成包装类对象。
这样我们只需要再定义一个二维数组，将上面 3 个数组放入即可：
Object[ ][ ] emps = new Object[3][ ];
emps[0] = a1;
emps[1] = a2;
emps[2] = a3;四、常见算法
1.冒泡排序的基础算法
1.1冒泡排序的基础算法
冒泡排序算法重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来，这样越大的元素会经由交换慢慢“浮”到数列的顶端。冒泡排序算法的运作如下：
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
示例：冒泡排序的基础算法
package cn.pxy.test;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] values= {3,1,6,2,9,0,7,4,5,8};
System.out.println(Arrays.toString(values));
bubbleSort(values);
System.out.println(Arrays.toString(values));
}
public static void bubbleSort(int[] values) {
int temp;
for(int i=0;i<values.length;i++) {
for(int j=0;j<values.length-1-i;j++) {
if(values[j]>values[j+1]) {
temp=values[j];
values[j]=values[j+1];
values[j+1]=temp;
}
}
}
}
}运行结果：
视频加载中...
上面为冒泡排序的执行动画，动画效果可以在下面这个网页上看：https://visualgo.net/
这个网站汇聚了各种算法，可以用程序和动画结合的方式学习，想详细理解算法，可以借助这个网站。
1.2冒泡排序的优化算法
其实，我们可以把1.1的冒泡排序的算法优化一下，基于冒泡排序的以下特点：
1.整个数列分成两部分：前面是无序数列，后面是有序数列。
2.初始状态下，整个数列都是无序的，有序数列是空。
3.每一趟循环可以让无序数列中最大数排到最后，（也就是说有序数列的元素个数增加1），也就是不用再去顾及有序序列。
4.每一趟循环都从数列的第一个元素开始进行比较，依次比较相邻的两个元素，比较到无序数列的末尾即可（而不是数列的末尾）；如果前一个大于后一个，交换。
5.判断每一趟是否发生了数组元素的交换，如果没有发生，则说明此时数组已经有序，无需再进行后续趟数的比较了。此时可以中止比较。
示例：
package cn.pxy.test;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] values= {3,1,6,2,9,0,7,4,5,8};
System.out.println(Arrays.toString(values));
bubbleSort(values);
System.out.println(Arrays.toString(values));
}
public static void bubbleSort(int[] values) {
int temp;
int i;
//外层循环：n个元素排序，则至多需要n-1趟循环
for(i=0;i<values.length-1;i++) {
//定义一个布尔类型的变量，标记数组是否已达到有序状态
boolean flag=true;
/*内层循环：每一趟循环都从数列的前两个元素开始进行比较，比较到
* 无序数组的最后*/
for(int j=0;j<values.length-1-i;j++) {
//如果前一个元素大于后一个元素，则交换两元素的值
if(values[j]>values[j+1]) {
temp=values[j];
values[j]=values[j+1];
values[j+1]=temp;
//本趟发生了交换，表明该数组在本趟处于无序状态，需要继续比较
flag=false;
}
}
//根据标记量的值判断数组是否有序，如果有序，则退出；无序，则继续循环
if(flag) {
break;
}
}
}
}运行结果：
2.二分法查找
二分法检索（binary search）又称折半检索，二分法检索的基本思想是设数组中的元素从小到大有序地存放在数组（array）中，首先将给定值 key 与数组中间位置上元素的关键码(key)比较，如果相等，则检索成功；
否则，若 key 小，则在数组前半部分中继续进行二分法检索;若 key 大，则在数组后半部分中继续进行二分法检索。
这样，经过一次比较就缩小一半的检索区间，如此进行下去，直到检索成功或检索失败。二分法检索是一种效率较高的检索方法。比如，我们要在数组[7, 8, 9, 10, 12, 20, 30, 40, 50,80, 100]中查询到 10 元素，过程如下：
示例：
package cn.pxy.test;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr= {30,10,60,20,90,9,70,40,50,80};
int searchWord=20;//要查找的数
Arrays.sort(arr);//二分法查找前一定要对数组元素排序
System.out.println(Arrays.toString(arr));
System.out.println(searchWord+"元素索引："+binarySearch(arr,searchWord));
}
public static int binarySearch(int[] array,int values) {
int low=0;
int high=array.length-1;
while(low<=high) {
int middle=(low+high)/2;
if(values==array[middle]) {
return middle;//返回查询到的索引位置
}
if(values>array[middle]) {
low=middle+1;
}
if(values<array[middle]) {
high=middle-1;
}
}
return -1;//上面循环完毕，说明未找到，返回-1
}
}运行结果：
五、数组演练示例
1.获取称为数组最小值
代码如下：
package cn.pxy.test;
import java.awt.BorderLayout;
import java.awt.EventQueue;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;
import javax.swing.UIManager;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.util.Arrays;
public class ArrayMinValue extends JFrame {
private JPanel contentPane;
private JTextField textField;
private JLabel label;
private JLabel label_1;
public static void main(String[] args) {
try {
UIManager
.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
} catch (Throwable e) {
e.printStackTrace();
}
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
ArrayMinValue frame = new ArrayMinValue();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
public ArrayMinValue() {
setTitle("获取一维数组的最小值");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 450, 149);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(null);
textField = new JTextField();
textField.setBounds(6, 36, 414, 30);
contentPane.add(textField);
textField.setColumns(10);
JButton button = new JButton("计算");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
do_button_actionPerformed(e);
}
});
button.setBounds(16, 76, 90, 30);
contentPane.add(button);
label = new JLabel("数组中最小的数是：");
label.setBounds(116, 82, 304, 18);
contentPane.add(label);
label_1 = new JLabel("请在文本框中输入多个整数，以空格隔开！！");
label_1.setBounds(6, 6, 422, 18);
contentPane.add(label_1);
}
protected void do_button_actionPerformed(ActionEvent e) {
String arrayStr = textField.getText().trim();
for (int i = 0; i < arrayStr.length(); i++) {// 过滤非法输入
char charAt = arrayStr.charAt(i);
if (!Character.isDigit(charAt) && charAt != ' ') {
JOptionPane.showMessageDialog(null, "输入包含非数字内容");
textField.setText("");
return;
}
}
String[] numStrs = arrayStr.split(" {1,}");// 分割字符串
int[] numArray = new int[numStrs.length];// 创建整数数组
// 转换输入为整数数组
for (int i = 0; i < numArray.length; i++) {
numArray[i] = Integer.valueOf(numStrs[i]);
}
int min = numArray[0];// 创建最小数变量
for (int j = 0; j < numArray.length; j++) {
if (min > numArray[j]) {// 提取最小整数
min = numArray[j];
}
}
label.setText("数组中最小的数是：" + min);
}
}运行结果：
2.将二维数组的行列互换
代码如下：
package cn.pxy.test;
public class ArrayRowColumnSwap {
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[i].length;j++) {
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}运行结果：
3.利用数组随机抽取幸运观众
代码如下：
package cn.pxy.test;
import java.awt.BorderLayout;
import java.awt.EventQueue;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JLabel;
import javax.swing.JComboBox;
import javax.swing.JTextField;
import javax.swing.JTextArea;
import javax.swing.JScrollPane;
import javax.swing.border.TitledBorder;
import javax.swing.JButton;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.util.Random;
import javax.swing.UIManager;
import java.awt.Color;
public class ArrayExample extends JFrame {
private JPanel contentPane;
private JTextField nameField;
private JTextArea personnelArea;
private JTextArea resultArea;
public static void main(String[] args) {
try {
UIManager
.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
} catch (Throwable e) {
e.printStackTrace();
}
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
ArrayExample frame = new ArrayExample();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
public ArrayExample() {
setTitle("利用数组抽取幸运观众");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 498, 300);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(null);
JPanel panel = new JPanel();
panel
.setBorder(new TitledBorder(
null,
"输入在场观众姓名，按回车",
TitledBorder.LEADING, TitledBorder.TOP, null,
new Color(59, 59, 59)));
panel.setBounds(10, 10, 174, 242);
contentPane.add(panel);
panel.setLayout(new BorderLayout(0, 5));
nameField = new JTextField();
nameField.addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
do_textField_keyPressed(e);
}
});
panel.add(nameField, BorderLayout.NORTH);
nameField.setColumns(10);
JScrollPane scrollPane = new JScrollPane();
panel.add(scrollPane);
personnelArea = new JTextArea();
personnelArea.setEditable(false);
scrollPane.setViewportView(personnelArea);
JPanel panel_1 = new JPanel();
panel_1.setBorder(new TitledBorder(null,
"选取幸运观众",
TitledBorder.LEADING, TitledBorder.TOP, null, new Color(59, 59,
59)));
panel_1.setBounds(183, 10, 219, 242);
contentPane.add(panel_1);
panel_1.setLayout(new BorderLayout(0, 0));
JScrollPane scrollPane_1 = new JScrollPane();
panel_1.add(scrollPane_1);
resultArea = new JTextArea();
resultArea.setEditable(false);
resultArea.setLineWrap(true);
scrollPane_1.setViewportView(resultArea);
JButton button = new JButton("抽取");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
do_button_actionPerformed(e);
}
});
button.setBounds(407, 164, 63, 25);
contentPane.add(button);
JButton button_1 = new JButton("退出");
button_1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
do_button_1_actionPerformed(e);
}
});
button_1.setBounds(407, 215, 63, 25);
contentPane.add(button_1);
}
protected void do_textField_keyPressed(KeyEvent e) {
if (e.getKeyChar() != '\n')// 不是回车字符不做处理
return;
String name = nameField.getText();
if (name.isEmpty())// 如果文本框没有字符串不做处理
return;
personnelArea.append(name + "\n");// 把输入人名与回车符添加到人员列表
nameField.selectAll();// 选择文本框所有字符
}
protected void do_button_actionPerformed(ActionEvent e) {
String perstring = personnelArea.getText();// 获取人员列表文本
String[] personnelArray = perstring.split("\n{1,}");// 获取人员数组
int index = (int) (Math.random() * personnelArray.length);// 生成随机数组索引
// 定义包含格式参数的中奖信息
String formatArg = "本次抽取观众人员：\n\t%1$s\n恭喜%1$s成为本次观众抽奖的大奖得主。"
+ "\n\n我们将为%1$s颁发：\n\t过期的酸奶二十箱。";
// 为中奖信息添加人员参数
String info = String.format(formatArg, personnelArray[index]);
resultArea.setText(info);// 在文本域显示中间信息
}
protected void do_button_1_actionPerformed(ActionEvent e) {
dispose();
}
}运行结果：
4.反转数组中元素的顺序
以相反的顺序把原有的数组的内容重新排列。
代码如下：
package cn.pxy.test;
import java.awt.EventQueue;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.border.EmptyBorder;
import javax.swing.UIManager;
import javax.swing.JTextField;
import javax.swing.JLabel;
public class ReverseSort extends JFrame {
private JPanel contentPane;
public static void main(String[] args) {
try {
UIManager
.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
} catch (Throwable e) {
e.printStackTrace();
}
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
ReverseSort frame = new ReverseSort();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
public ReverseSort() {
setTitle("反转数组中元素的顺序");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 450, 300);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
GridBagLayout gbl_contentPane = new GridBagLayout();
gbl_contentPane.columnWidths = new int[] { 0, 0 };
gbl_contentPane.rowHeights = new int[] { 0, 0, 0, 0, 0, 0 };
gbl_contentPane.columnWeights = new double[] { 1.0, Double.MIN_VALUE };
gbl_contentPane.rowWeights = new double[] { 0.0, 0.0, 0.0, 1.0, 0.0,
Double.MIN_VALUE };
contentPane.setLayout(gbl_contentPane);
label = new JLabel(
"输入数组的内容，以空格分割数组元素");
GridBagConstraints gbc_label = new GridBagConstraints();
gbc_label.anchor = GridBagConstraints.WEST;
gbc_label.insets = new Insets(0, 0, 5, 0);
gbc_label.gridx = 0;
gbc_label.gridy = 0;
contentPane.add(label, gbc_label);
textField = new JTextField();
GridBagConstraints gbc_textField = new GridBagConstraints();
gbc_textField.fill = GridBagConstraints.HORIZONTAL;
gbc_textField.insets = new Insets(0, 0, 5, 0);
gbc_textField.gridx = 0;
gbc_textField.gridy = 1;
contentPane.add(textField, gbc_textField);
label_1 = new JLabel("数组元素反转：");
GridBagConstraints gbc_label_1 = new GridBagConstraints();
gbc_label_1.anchor = GridBagConstraints.WEST;
gbc_label_1.insets = new Insets(0, 0, 5, 0);
gbc_label_1.gridx = 0;
gbc_label_1.gridy = 2;
contentPane.add(label_1, gbc_label_1);
JScrollPane scrollPane_1 = new JScrollPane();
GridBagConstraints gbc_scrollPane_1 = new GridBagConstraints();
gbc_scrollPane_1.insets = new Insets(0, 0, 5, 0);
gbc_scrollPane_1.fill = GridBagConstraints.BOTH;
gbc_scrollPane_1.gridx = 0;
gbc_scrollPane_1.gridy = 3;
contentPane.add(scrollPane_1, gbc_scrollPane_1);
textArea = new JTextArea();
scrollPane_1.setViewportView(textArea);
JButton button_1 = new JButton("反转排序法");
button_1.setActionCommand("快速排序法");
button_1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
do_button_1_actionPerformed(e);
}
});
GridBagConstraints gbc_button_1 = new GridBagConstraints();
gbc_button_1.gridx = 0;
gbc_button_1.gridy = 4;
contentPane.add(button_1, gbc_button_1);
}
private JTextField textField;
private JTextArea textArea;
private JLabel label;
private JLabel label_1;
protected void do_button_1_actionPerformed(ActionEvent e) {
String inText = textField.getText();// 获取用户输入
String[] array = inText.split(" {1,}");
int len = array.length;
textArea.setText("");
for (int i = 0; i < len / 2; i++) {
String temp = array[i];
array[i] = array[len - 1 - i];
array[len - 1 - i] = temp;
for (String string : array) {
textArea.append(string + " ");
}
textArea.append("\n");
}
}
}运行结果：
运行过程：初始数据：【10 20 30 40 50 60 70 80 90】
第一趟：90【20 30 40 50 60 70 80】10
第二趟：90 80【30 40 50 60 70】20 10
第三趟：90 80 70【40 50 60】30 20 10
第四趟：90 80 70 60 【50】 40 30 20 10
5.使用选择排序法
选择排序的基本思路是：每一趟从待排序的数据元素中选择最小（或最大）的一个元素，顺序放在已排好序的数列最后，直到全部待排序的数据元素排完。
代码如下：
package cn.pxy.test;
import java.awt.BorderLayout;
import java.awt.EventQueue;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import java.awt.GridBagLayout;
import javax.swing.JScrollPane;
import java.awt.GridBagConstraints;
import javax.swing.JButton;
import java.awt.Insets;
import javax.swing.JTextArea;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.util.Random;
public class SelectSort extends JFrame {
private JPanel contentPane;
/**
* Launch the application.
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
SelectSort frame = new SelectSort();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* Create the frame.
*/
public SelectSort() {
setTitle("选择排序法");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 450, 300);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
GridBagLayout gbl_contentPane = new GridBagLayout();
gbl_contentPane.columnWidths = new int[] { 0, 0 };
gbl_contentPane.rowHeights = new int[] { 0, 0, 0, 0, 0 };
gbl_contentPane.columnWeights = new double[] { 1.0, Double.MIN_VALUE };
gbl_contentPane.rowWeights = new double[] { 1.0, 0.0, 1.0, 0.0,
Double.MIN_VALUE };
contentPane.setLayout(gbl_contentPane);
JScrollPane scrollPane = new JScrollPane();
GridBagConstraints gbc_scrollPane = new GridBagConstraints();
gbc_scrollPane.insets = new Insets(0, 0, 5, 0);
gbc_scrollPane.fill = GridBagConstraints.BOTH;
gbc_scrollPane.gridx = 0;
gbc_scrollPane.gridy = 0;
contentPane.add(scrollPane, gbc_scrollPane);
textArea1 = new JTextArea();
scrollPane.setViewportView(textArea1);
JButton button = new JButton("生成随机数");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
do_button_actionPerformed(e);
}
});
GridBagConstraints gbc_button = new GridBagConstraints();
gbc_button.insets = new Insets(0, 0, 5, 0);
gbc_button.gridx = 0;
gbc_button.gridy = 1;
contentPane.add(button, gbc_button);
JScrollPane scrollPane_1 = new JScrollPane();
GridBagConstraints gbc_scrollPane_1 = new GridBagConstraints();
gbc_scrollPane_1.insets = new Insets(0, 0, 5, 0);
gbc_scrollPane_1.fill = GridBagConstraints.BOTH;
gbc_scrollPane_1.gridx = 0;
gbc_scrollPane_1.gridy = 2;
contentPane.add(scrollPane_1, gbc_scrollPane_1);
textArea2 = new JTextArea();
scrollPane_1.setViewportView(textArea2);
JButton button_1 = new JButton("选择排序法");
button_1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
do_button_1_actionPerformed(e);
}
});
GridBagConstraints gbc_button_1 = new GridBagConstraints();
gbc_button_1.gridx = 0;
gbc_button_1.gridy = 3;
contentPane.add(button_1, gbc_button_1);
}
private int[] array = new int[10];
private JTextArea textArea1;
private JTextArea textArea2;
protected void do_button_actionPerformed(ActionEvent e) {
Random random = new Random();// 创建随机数对象
textArea1.setText("");// 清空文本域
for (int i = 0; i < array.length; i++) {// 初始化数组元素
array[i] = random.nextInt(50);// 生成50以内的随机数
textArea1.append(array[i]+" ");// 把数组元素显示的文本域控件中
}
}
protected void do_button_1_actionPerformed(ActionEvent e) {
textArea2.setText("");// 清空文本域
int index;
for (int i = 1; i < array.length; i++) {
index = 0;
for (int j = 1; j <= array.length - i; j++) {
if (array[j] > array[index]) {
index = j;// 查找最大值
}
}
// 交换在位置array.length-i和index(最大值)两个数
int temp = array[array.length - i];
array[array.length - i] = array[index];
array[index] = temp;
}
for (int i = 0; i < array.length; i++) {
textArea2.append(array[i] + " ");// 把排序后的数组元素显示到文本域中
}
}
}运行结果：
6.使用冒泡排序
代码如下：
package cn.pxy.test;
import java.awt.BorderLayout;
import java.awt.EventQueue;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import java.awt.GridBagLayout;
import javax.swing.JScrollPane;
import java.awt.GridBagConstraints;
import javax.swing.JButton;
import java.awt.Insets;
import javax.swing.JTextArea;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.util.Random;
public class BubbleSort extends JFrame {
private JPanel contentPane;
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
BubbleSort frame = new BubbleSort();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* Create the frame.
*/
public BubbleSort() {
setTitle("冒泡排序法");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 450, 300);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
GridBagLayout gbl_contentPane = new GridBagLayout();
gbl_contentPane.columnWidths = new int[] { 0, 0 };
gbl_contentPane.rowHeights = new int[] { 0, 0, 0, 0, 0 };
gbl_contentPane.columnWeights = new double[] { 1.0, Double.MIN_VALUE };
gbl_contentPane.rowWeights = new double[] { 1.0, 0.0, 1.0, 0.0,
Double.MIN_VALUE };
contentPane.setLayout(gbl_contentPane);
JScrollPane scrollPane = new JScrollPane();
GridBagConstraints gbc_scrollPane = new GridBagConstraints();
gbc_scrollPane.insets = new Insets(0, 0, 5, 0);
gbc_scrollPane.fill = GridBagConstraints.BOTH;
gbc_scrollPane.gridx = 0;
gbc_scrollPane.gridy = 0;
contentPane.add(scrollPane, gbc_scrollPane);
textArea1 = new JTextArea();
scrollPane.setViewportView(textArea1);
JButton button = new JButton("生成随机数");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
do_button_actionPerformed(e);
}
});
GridBagConstraints gbc_button = new GridBagConstraints();
gbc_button.insets = new Insets(0, 0, 5, 0);
gbc_button.gridx = 0;
gbc_button.gridy = 1;
contentPane.add(button, gbc_button);
JScrollPane scrollPane_1 = new JScrollPane();
GridBagConstraints gbc_scrollPane_1 = new GridBagConstraints();
gbc_scrollPane_1.insets = new Insets(0, 0, 5, 0);
gbc_scrollPane_1.fill = GridBagConstraints.BOTH;
gbc_scrollPane_1.gridx = 0;
gbc_scrollPane_1.gridy = 2;
contentPane.add(scrollPane_1, gbc_scrollPane_1);
textArea2 = new JTextArea();
scrollPane_1.setViewportView(textArea2);
JButton button_1 = new JButton("冒泡排序法");
button_1.setActionCommand("冒泡排序法");
button_1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
do_button_1_actionPerformed(e);
}
});
GridBagConstraints gbc_button_1 = new GridBagConstraints();
gbc_button_1.gridx = 0;
gbc_button_1.gridy = 3;
contentPane.add(button_1, gbc_button_1);
}
private int[] array = new int[10];
private JTextArea textArea1;
private JTextArea textArea2;
protected void do_button_actionPerformed(ActionEvent e) {
Random random = new Random();// 创建随机数对象
textArea1.setText("");// 清空文本域
for (int i = 0; i < array.length; i++) {// 初始化数组元素
array[i] = random.nextInt(50);// 生成50以内的随机数
textArea1.append(array[i] + " ");// 把数组元素显示的文本域控件中
}
}
protected void do_button_1_actionPerformed(ActionEvent e) {
textArea2.setText("");// 清空文本域
for (int i = 1; i < array.length; i++) {
// 比较相邻两个元素，较大的数往后冒泡
for (int j = 0; j < array.length - i; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];// 把第一个元素值保持到临时变量中
array[j] = array[j + 1];// 把第二个元素值保存到第一个元素单元中
array[j + 1] = temp;// 把临时变量也就是第一个元素原值保持到第二个元素中
}
textArea2.append(array[j] + " ");// 把排序后的数组元素显示到文本域中
}
textArea2.append("【");
for (int j = array.length - i; j < array.length; j++) {
textArea2.append(array[j] + " ");// 把排序后的数组元素显示到文本域中
}
textArea2.append("】\n");
}
}
}运行结果：
7.使用快速排序法
快速排序法是对冒泡排序算法的一种改进，它的基本思想是，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的数据比另一部分的所有数据都要小，然后再按此方法对两部分数据分别进行快速排序，整个排序过程可以递归进行，以此使整个数据变成有序序列。
代码如下：
package cn.pxy.test;
import java.awt.EventQueue;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.border.EmptyBorder;
import javax.swing.UIManager;
import javax.swing.JTextField;
public class QuickSort extends JFrame {
private JPanel contentPane;
public static void main(String[] args) {
try {
UIManager
.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
} catch (Throwable e) {
e.printStackTrace();
}
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
QuickSort frame = new QuickSort();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* Create the frame.
*/
public QuickSort() {
setTitle("快速排序法");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 450, 300);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
GridBagLayout gbl_contentPane = new GridBagLayout();
gbl_contentPane.columnWidths = new int[] { 0, 0 };
gbl_contentPane.rowHeights = new int[] { 0, 0, 0, 0, 0 };
gbl_contentPane.columnWeights = new double[] { 1.0, Double.MIN_VALUE };
gbl_contentPane.rowWeights = new double[] { 0.0, 0.0, 1.0, 0.0,
Double.MIN_VALUE };
contentPane.setLayout(gbl_contentPane);
JButton button = new JButton("生成随机数");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
do_button_actionPerformed(e);
}
});
textField = new JTextField();
GridBagConstraints gbc_textField = new GridBagConstraints();
gbc_textField.fill = GridBagConstraints.HORIZONTAL;
gbc_textField.insets = new Insets(0, 0, 5, 0);
gbc_textField.gridx = 0;
gbc_textField.gridy = 0;
contentPane.add(textField, gbc_textField);
GridBagConstraints gbc_button = new GridBagConstraints();
gbc_button.insets = new Insets(0, 0, 5, 0);
gbc_button.gridx = 0;
gbc_button.gridy = 1;
contentPane.add(button, gbc_button);
JScrollPane scrollPane_1 = new JScrollPane();
GridBagConstraints gbc_scrollPane_1 = new GridBagConstraints();
gbc_scrollPane_1.insets = new Insets(0, 0, 5, 0);
gbc_scrollPane_1.fill = GridBagConstraints.BOTH;
gbc_scrollPane_1.gridx = 0;
gbc_scrollPane_1.gridy = 2;
contentPane.add(scrollPane_1, gbc_scrollPane_1);
textArea2 = new JTextArea();
scrollPane_1.setViewportView(textArea2);
JButton button_1 = new JButton("快速排序法");
button_1.setActionCommand("快速排序法");
button_1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
do_button_1_actionPerformed(e);
}
});
GridBagConstraints gbc_button_1 = new GridBagConstraints();
gbc_button_1.gridx = 0;
gbc_button_1.gridy = 3;
contentPane.add(button_1, gbc_button_1);
}
private int[] array = new int[10];
private JTextField textField;
private JTextArea textArea2;
protected void do_button_actionPerformed(ActionEvent e) {
Random random = new Random();// 创建随机数对象
String text = "";
for (int i = 0; i < array.length; i++) {// 初始化数组元素
array[i] = random.nextInt(90);// 生成50以内的随机数
text += (array[i] + " ");// 把数组元素显示的文本域控件中
}
textField.setText(text);
}
protected void do_button_1_actionPerformed(ActionEvent e) {
textArea2.setText("");// 清空文本域
quickSort(array, 0, array.length - 1);// 调用快速排序算法
}
private 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);
}
}
private void swap(int swapArray[], int i, int j) {
int temp = swapArray[i];// 交换数组元素
swapArray[i] = swapArray[j];
swapArray[j] = temp;
for (int k = 0; k < array.length; k++) {// 把数组元素显示到文本域
textArea2.append(array[k] + " ");
}
textArea2.append("\n");// 追加换行符
}
}运行结果：
8.使用直接插入法
插入排序是将一个记录插入到有序数列中，使得到的新数列任然有序。插入排序的思想是，将n个有序数存在数组a中，要插入的数为x，首先确定x插在数组中的位置p，数组中p之后的元素都向后移一个位置，空出a(p)，将x放入。这样即可实现插入后数列任然有序。
代码如下：
package cn.pxy.test;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.border.EmptyBorder;
import javax.swing.UIManager;
public class InsertSort extends JFrame {
private JPanel contentPane;
public static void main(String[] args) {
try {
UIManager.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
} catch (Throwable e) {
e.printStackTrace();
}
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
InsertSort frame = new InsertSort();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* Create the frame.
*/
public InsertSort() {
setTitle("使用直接插入法");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 335, 300);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(null);
textArea1 = new JTextArea();
textArea1.setBounds(6, 6, 86, 250);
contentPane.add(textArea1);
JButton button = new JButton("生成随机数");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
do_button_actionPerformed(e);
}
});
button.setBounds(104, 49, 114, 30);
contentPane.add(button);
JButton button_1 = new JButton("直接插入法");
button_1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
do_button_1_actionPerformed(e);
}
});
button_1.setBounds(104, 161, 114, 30);
contentPane.add(button_1);
textArea2 = new JTextArea();
textArea2.setBounds(230, 6, 86, 250);
contentPane.add(textArea2);
}
private int[] array = new int[10];
private JTextArea textArea1;
private JTextArea textArea2;
protected void do_button_actionPerformed(ActionEvent e) {
Random random = new Random();// 创建随机数对象
textArea1.setText("");
for (int i = 0; i < array.length; i++) {// 初始化数组元素
array[i] = random.nextInt(90);// 生成50以内的随机数
textArea1.append(array[i] + "\n");// 把数组元素显示的文本域控件中
}
}
protected void do_button_1_actionPerformed(ActionEvent e) {
int tmp;// 定义临时变量
int j;
for (int i = 1; i < array.length; i++) {
tmp = array[i];// 保存临时变量
for (j = i - 1; j >= 0 && array[j] > tmp; j--) {
array[j + 1] = array[j];// 数组元素交换
}
array[j + 1] = tmp;// 在排序位置插入数据
}
textArea2.setText("");
for (int i = 0; i < array.length; i++) {// 初始化数组元素
textArea2.append(array[i] + "\n");// 把数组元素显示的文本域控件中
}
}
}运行结果：
请先 后发表评论～