Java实例,对10个数进行排序

题44：编程输入10个正整数，然后自动按从大到小的顺序输出。

题44：编程输入10个正整数，然后自动按从大到小的顺序输出。

Input输入只有一行，包括10整数.Output输出只有一行,包括10个整数。

Sample Input1 2 3 4 5 7 6 8 9 10Sample Output10 9 8 7 6 5 4 3 2 1提示：数组与排序，注意输出最后一个空格要考虑。

处理方法最后一个单独输出。

program ex_44;var a:array[1..10] of integer;i,j,t:integer;beginfor i:=1 to 10 do read(a[i]);for i:=1 to 9 dofor j:=i+1 to 10 doif a[i]<a[j] then begin t:=a[i];a[i]:=a[j];a[j]:=t; end;for i:=1 to 9 do write(a[i],' ');write(a[10]);end.题46：统计字母出现次数输入一串小写字母（以"."为结束标志），统计出每个字母在该字符串中出现的次数(若某字母不出现，则不要输出)。

Input输入只有一行，包括若干个字符。

Output输出只有两行，第一行为出现的小写字母，第二行为字母的出现次数。

Sample Inputabdceeef.Sample Outputabcdef111131提示：注意利用字符做下标，可以让程序简单。

program ex_45;var a:array['a'..'z'] of integer;i,ch:char;beginread(ch);for i:='a' to 'z' do a[i]:=0;while ch<>'.' dobegina[ch]:=a[ch]+1;read(ch);end;for i:='a' to 'z' doif a[i]<>0 then write(i);writeln;for i:='a' to 'z' doif a[i]<>0 then write(a[i]);end.题48：求序列中所有递增或递减子序列的个数并输出子序列题48：求序列中所有递增或递减子序列的个数并输出子序列。

第六次1、编写程序，输入10个学生成绩，求出最高分、最低分、总分和平均分。

#include<stdio.h>main(){float average,max,min,sum,a[10];int i;printf("请输入10个成绩:\n");for(i=0;i<10;i++)scanf("%f",&a[i]);max=a[0],min=a[0],sum=0;for(i=0;i<10;i++){sum=sum+a[i];if(a[i]>max)max=a[i];if(a[i]<min)min=a[i];}average=sum/10.0;printf("最大值:%.2f\t最小值:%.2f\t总分:%.2f\t平均分:%.2f",max,min,sum,average);}2、输入8个数,用冒泡法实现升序排列. #include<stdio.h>main(){int a[8],i,j,k;printf("请输入8个数:\n");for(i=0;i<8;i++)scanf("%d",&a[i]);for(i=0;i<7;i++)for(j=7;j>=i+1;j--){if(a[j]<a[j-1]){k=a[j];a[j]=a[j-1];a[j-1]=k;}}for(i=0;i<8;i++)printf("%d",a[i]);}3、编写程序，将一个十进制正整数转换成16位二进制形式输出。

提示:“除2取余”法，可定义一维数组保存每次求余运算的结果。

例如：输入：16输出：0000,0000,0001,0000,#include<stdio.h>void bob(int m){char hi[17];int i,n;n=m;for(i=15;i>=0;i--){if(m%2==1)hi[i]='1';if(m%2==0)hi[i]='0';m=m/2;}hi[16]='\0';printf("n=%d\n二进制形式是\n%s\n",n,hi);}void main(){int num;printf("请输入一个十进制正整数:\n");scanf("%d",&num);bob(num);}4、求500以内的所有亲密数对。

java获取十位随机数的方法摘要：1.引言2.获取十位随机数的方法a.使用java.util.Random类b.使用java.util.concurrent.ThreadLocalRandom类c.使用Math.random()方法3.示例代码4.总结正文：在Java编程中，获取随机数是非常常见的操作。

本文将介绍三种获取十位随机数的方法。

首先，我们可以使用java.util.Random类。

这个类提供了多种方法来生成随机数。

以下是一个使用Random类获取十位随机数的示例代码：```javaimport java.util.Random;public class RandomNumber {public static void main(String[] args) {Random rand = new Random();int randomNumber = rand.nextInt(9000000000) + 1000000000; // 生成一个十位随机数System.out.println("十位随机数: " + randomNumber);}}```其次，我们可以使用java.util.concurrent.ThreadLocalRandom类。

这个类是Java 7引入的，它提供了线程安全的随机数生成器。

以下是一个使用ThreadLocalRandom类获取十位随机数的示例代码：```javaimport java.util.concurrent.ThreadLocalRandom;public class RandomNumber {public static void main(String[] args) {int randomNumber =ThreadLocalRandom.current().nextInt(1000000000, 999999999); // 生成一个十位随机数System.out.println("十位随机数: " + randomNumber);}}```最后，我们还可以使用Math.random()方法。

Java中List排序的三种实现⽅法实例⽬录前⾔1.使⽤ Comparable 排序2.使⽤ Comparator 排序2.1 新建 Comparator ⽐较器2.2 匿名类⽐较器3.使⽤ Stream 流排序总结前⾔在某些特殊的场景下，我们需要在 Java 程序中对 List 集合进⾏排序操作。

⽐如从第三⽅接⼝中获取所有⽤户的列表，但列表默认是以⽤户编号从⼩到⼤进⾏排序的，⽽我们的系统需要按照⽤户的年龄从⼤到⼩进⾏排序，这个时候，我们就需要对 List 集合进⾏⾃定义排序操作了。

L ist 排序的常见⽅法有以下 3 种：1. 使⽤ Comparable 进⾏排序；2. 使⽤ Comparator 进⾏排序；3. 如果是 JDK 8 以上的环境，也可以使⽤ Stream 流进⾏排序。

下⾯我们分别来看各种排序⽅法的具体实现。

1.使⽤ Comparable 排序按照本⽂设计的场景，我们需要创建⼀个包含了⽤户列表的 List 集合，并按⽤户的年龄从⼤到⼩进⾏排序，具体实现代码如下：public class ListSortExample {public static void main(String[] args) {// 创建并初始化 ListList<Person> list = new ArrayList<Person>() {{add(new Person(1, 30, "北京"));add(new Person(2, 20, "西安"));add(new Person(3, 40, "上海"));}};// 使⽤ Comparable ⾃定的规则进⾏排序Collections.sort(list);// 打印 list 集合list.forEach(p -> {System.out.println(p);});}}// 以下 set/get/toString 使⽤的是 lombok 的注解@Getter@Setter@ToStringclass Person implements Comparable<Person> {private int id;private int age;private String name;public Person(int id, int age, String name) {this.id = id;this.age = age; = name;}@Overridepublic int compareTo(Person p) {return p.getAge() - this.getAge();}}以上代码的执⾏结果，如下图所⽰：本⽅法的核⼼代码如下：2.使⽤ Comparator 排序Comparable 是类内部的⽐较⽅法，⽽ Comparator 是排序类外部的⽐较器。

哈希排序算法java实现哈希排序算法的Java实现哈希排序算法是一种基于哈希表的排序算法，它利用哈希函数将元素映射到桶中，并通过对桶中的元素进行排序，最终得到有序的结果。

在本文中，我们将介绍哈希排序算法的原理，并给出其Java实现。

一、算法原理哈希排序算法的核心思想是利用哈希函数将元素映射到桶中，然后对桶中的元素进行排序。

具体步骤如下：1. 创建一个哈希表，用于存储桶。

2. 根据哈希函数将待排序的元素分配到相应的桶中。

3. 对每个桶中的元素进行排序，可以使用插入排序或其他排序算法。

4. 将每个桶中的元素按顺序合并到一个有序数组中，即为最终的排序结果。

二、Java实现下面是哈希排序算法的Java实现代码：```javaimport java.util.ArrayList;import java.util.Collections;public class HashSort {public static void hashSort(int[] arr) {// 创建一个哈希表，用于存储桶ArrayList<ArrayList<Integer>> buckets = new ArrayList<>();int max = arr[0], min = arr[0];int bucketNum;// 找出待排序数组中的最大值和最小值for (int i = 1; i < arr.length; i++) {if (arr[i] > max) {max = arr[i];}if (arr[i] < min) {min = arr[i];}}// 计算桶的数量bucketNum = (max - min) / arr.length + 1;// 初始化桶for (int i = 0; i < bucketNum; i++) {buckets.add(new ArrayList<>());}// 根据哈希函数将元素分配到相应的桶中for (int i = 0; i < arr.length; i++) {int index = (arr[i] - min) / arr.length;buckets.get(index).add(arr[i]);}// 对每个桶中的元素进行排序for (ArrayList<Integer> bucket : buckets) {Collections.sort(bucket);}// 将每个桶中的元素按顺序合并到一个有序数组中 int index = 0;for (ArrayList<Integer> bucket : buckets) {for (int num : bucket) {arr[index++] = num;}}}public static void main(String[] args) {int[] arr = {9, 5, 7, 3, 1, 6, 8, 2, 4};hashSort(arr);for (int num : arr) {System.out.print(num + " ");}}}```在上述代码中，我们首先找出待排序数组中的最大值和最小值，然后根据哈希函数将元素分配到相应的桶中。

⽤Java实现常见的8种内部排序算法⼀、插⼊类排序插⼊类排序就是在⼀个有序的序列中，插⼊⼀个新的关键字。

从⽽达到新的有序序列。

插⼊排序⼀般有直接插⼊排序、折半插⼊排序和希尔排序。

1. 插⼊排序1.1 直接插⼊排序/*** 直接⽐较，将⼤元素向后移来移动数组*/public static void InsertSort(int[] A) {for(int i = 1; i < A.length; i++) {int temp = A[i]; //temp ⽤于存储元素，防⽌后⾯移动数组被前⼀个元素覆盖int j;for(j = i; j > 0 && temp < A[j-1]; j--) { //如果 temp ⽐前⼀个元素⼩，则移动数组A[j] = A[j-1];}A[j] = temp; //如果 temp ⽐前⼀个元素⼤，遍历下⼀个元素}}/*** 这⾥是通过类似于冒泡交换的⽅式来找到插⼊元素的最佳位置。

⽽传统的是直接⽐较，移动数组元素并最后找到合适的位置*/public static void InsertSort2(int[] A) { //A[] 是给定的待排数组for(int i = 0; i < A.length - 1; i++) { //遍历数组for(int j = i + 1; j > 0; j--) { //在有序的序列中插⼊新的关键字if(A[j] < A[j-1]) { //这⾥直接使⽤交换来移动元素int temp = A[j];A[j] = A[j-1];A[j-1] = temp;}}}}/*** 时间复杂度：两个 for 循环 O(n^2)* 空间复杂度：占⽤⼀个数组⼤⼩，属于常量，所以是 O(1)*/1.2 折半插⼊排序/** 从直接插⼊排序的主要流程是：1.遍历数组确定新关键字 2.在有序序列中寻找插⼊关键字的位置* 考虑到数组线性表的特性，采⽤⼆分法可以快速寻找到插⼊关键字的位置，提⾼整体排序时间*/public static void BInsertSort(int[] A) {for(int i = 1; i < A.length; i++) {int temp = A[i];//⼆分法查找int low = 0;int high = i - 1;int mid;while(low <= high) {mid = (high + low)/2;if (A[mid] > temp) {high = mid - 1;} else {low = mid + 1;}}//向后移动插⼊关键字位置后的元素for(int j = i - 1; j >= high + 1; j--) {A[j + 1] = A[j];}//将元素插⼊到寻找到的位置A[high + 1] = temp;}}2. 希尔排序希尔排序⼜称缩⼩增量排序，其本质还是插⼊排序，只不过是将待排序列按某种规则分成⼏个⼦序列，然后如同前⾯的插⼊排序⼀般对这些⼦序列进⾏排序。

Java⽣成随机字符串数组的实例详解Java ⽣成随机字符串数组的实例详解利⽤Collections.sort()⽅法对泛型为String的List 进⾏排序。

具体要求：1.创建完List<String>之后，往其中添加⼗条随机字符串2.每条字符串的长度为10以内的随机整数3.每条字符串的每个字符都为随机⽣成的字符，字符可以重叠4.每条随机字符串不可重复将涉及到的知识有： String、StringBuffer、ListArray、泛型、Collections.sort、foreach、Random等相关知识，算是在JAVA 学习过程中⼀个⽐较好的的实践。

1. 随机⽣成⼀个字符1.1 先将所有的字母和0-9的数字存放于⼀个字符串中，以便后续使⽤。

String str = "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789";1.2 因为要满⾜随机性，所以创建⼀个 Random 对象，利⽤其中的 nextInt(str.length) ⽅法⽣成⼀个 0 — str.length 的随机数。

Random random = new Random();int index = random.nextInt(str.length());1.3 再将上述⽣成的随机数作为 str 字符串的索引取出相应的字符，及随机⽣成了⼀个字符char c = str.charAt(index);2. ⽣成⼀条长度为10以内的随机字符串2.1 因为是10以内且满⾜随机性，所以此处使⽤ Math.random() 函数，其返回值为随机 0.0 - 1.0 的 Double 类型的数StringBuffer stringBuffer = new StringBuffer();//确定字符串长度int stringLength = (int) (Math.random()*10);2.2 现在字符串的长度可以确认，也实现了⽣成随机的字符，再利⽤ for 循环就可以⽣成⼀条长度为10以内的随机字符串for (int j = 0; j < stringLength; j++) {int index = random.nextInt(str.length());char c = str.charAt(index);stringBuffer.append(c);}//将StringBuffer转换为String类型的字符串String string = stringBuffer.toString();3. ⽣成10条随机字符串3.1 经过上述的两个步骤，再在外部嵌套⼀个 for 循环就可以⽣成 10 条随机字符串4. 创建⼀个 ListArray<String> 集合储存着10条随机字符串4.1 创建⼀个 String 类型集合，该步奏应该和步奏3同步完成List<String> listString = new ArrayList<String>();4.2 将每次⽣成的⼀条字符串添加到集合中，注意利⽤集合的 Contains() ⽅法判断集合中之前是否已存在相同的字符串（虽然概率很⼩）。

Java程序员必知的8大排序2012-06-28 14:01 without0815 博客园我要评论(5)字号：T | T本文主要详解了Java语言的8大排序的基本思想以及实例解读，详细请看下文AD：51CTO云计算架构师峰会抢票进行中！8种排序之间的关系:1，直接插入排序（1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。

如此反复循环，直到全部排好顺序。

（2）实例（3）用java实现1.package com.njue;2.3.public class insertSort {4.public insertSort(){5.inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};6.int temp=0;7.for(int i=1;i<a.length;i++){8.int j=i-1;9. temp=a[i];10.for(;j>=0&&temp<a[j];j--){11. a[j+1]=a[j]; //将大于temp的值整体后移一个单位12. }13. a[j+1]=temp;14. }15.for(int i=0;i<a.length;i++)16. System.out.println(a[i]);17.}18.}2，希尔排序（最小增量排序）（1）基本思想：算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。

当增量减到1时，进行直接插入排序后，排序完成。

（2）实例：（3）用java实现1.public class shellSort {2.public shellSort(){3.int a[]={1,54,6,3,78,34,12,45,56,100};4.double d1=a.length;5.int temp=0;6.while(true){7. d1= Math.ceil(d1/2);8.int d=(int) d1;9.for(int x=0;x<d;x++){10.for(int i=x+d;i<a.length;i+=d){11.int j=i-d;12. temp=a[i];13.for(;j>=0&&temp<a[j];j-=d){14. a[j+d]=a[j];15. }16. a[j+d]=temp;17. }18. }19.if(d==1)20.break;21. }22.for(int i=0;i<a.length;i++)23. System.out.println(a[i]);24.}25.}3.简单选择排序（1）基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

Java集合排序及java集合类详解(Collection, List, Set, Map)摘要内容Java里面最重要，最常用也就是集合一部分了。

能够用好集合和理解好集合对于做Java程序的开发拥有无比的好处。

本文详细解释了关于Java中的集合是如何实现的，以及他们的实现原理。

关键字：Collection , List ,Set , Map , 集合，框架。

目录1 集合框架 (2)1.1 集合框架概述 (2)1.1.1 容器简介 (2)1.1.2 容器的分类 (4)1.2 Collection (6)1.2.1 常用方法 (6)1.2.2 迭代器 (8)1.3 List (10)1.3.1 概述 (10)1.3.2 常用方法 (11)1.3.3 实现原理 (15)1.4 Map (18)1.4.1 概述 (18)1.4.2 常用方法 (18)1.4.3 Comparable 接口 (23)1.4.4 实现原理 (25)1.4.5 覆写hashCode() (29)1.5 Set (33)1.5.1 概述 (33)1.5.2 常用方法 (34)1.5.3 实现原理 (38)1.6 总结:集合框架中常用类比较 (39)2 练习 (40)3 附录：排序 (41)1集合框架1.1集合框架概述1.1.1容器简介到目前为止，我们已经学习了如何创建多个不同的对象，定义了这些对象以后，我们就可以利用它们来做一些有意义的事情。

举例来说，假设要存储许多雇员，不同的雇员的区别仅在于雇员的身份证号。

我们可以通过身份证号来顺序存储每个雇员，但是在内存中实现呢？是不是要准备足够的内存来存储1000个雇员，然后再将这些雇员逐一插入？如果已经插入了500条记录，这时需要插入一个身份证号较低的新雇员，该怎么办呢？是在内存中将500条记录全部下移后，再从开头插入新的记录? 还是创建一个映射来记住每个对象的位置？当决定如何存储对象的集合时，必须考虑如下问题。

java list 树形数据排序方法Java中的List是一种常见的数据结构，它可以存储多个元素，并且可以动态地调整大小。

在实际的开发中，我们经常会遇到需要对树形数据进行排序的需求。

本文将介绍一些常用的方法和技巧，帮助我们对Java List中的树形数据进行排序。

一、树形数据结构简介树形数据结构是一种层次化的数据结构，它由节点和边组成。

每个节点可以有多个子节点，但只能有一个父节点，树形数据结构中的节点之间存在一种层次关系。

常见的树形数据结构有二叉树、多叉树和平衡树等。

二、List中树形数据的排序方法1. 自定义比较器在Java中，我们可以使用自定义比较器来对List中的树形数据进行排序。

比较器是一个实现了Comparator接口的类，它定义了比较两个对象的规则。

我们可以根据树形数据的特点，编写自定义比较器来实现排序。

例如，假设我们有一个树形数据的类TreeNode，它有一个属性value表示节点的值，还有一个属性children表示子节点列表。

我们可以编写一个自定义比较器TreeComparator来比较两个TreeNode对象的大小。

```javapublic class TreeComparator implements Comparator<TreeNode> {@Overridepublic int compare(TreeNode node1, TreeNode node2) {// 比较两个节点的值return node1.getValue().compareTo(node2.getValue());}}```然后，我们可以使用Collections.sort方法来对List中的树形数据进行排序。

```javaList<TreeNode> treeList = new ArrayList<>();// 添加树形数据到List中// ...// 使用自定义比较器进行排序Collections.sort(treeList, new TreeComparator());```2. 递归排序如果树形数据的结构比较复杂，或者我们需要按照多个属性进行排序，可以使用递归排序的方法。

JAVA期末考试试题一、单项选择题（每小题2分，共40分）．在Java中，负责对字节代码解释执行的是( )。

A、垃圾回收器B、虚拟机C、编译器D、多线程机制．int型public成员变量MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是( ) 。

A．public int MAX_LENGTH=100 B．final int MAX_LENGTH=100C．public const int MAX_LENGTH=100 D．public final int MAX_LENGTH=100 ．下列运算符合法的是（）。

A．&& B．<> C．if D．:=．执行如下程序代码a=0;c=0;do{--c;a=a-1;}while(a>0);后，C的值是（）。

A．0 B． 1 C．-1 D．死循环．下列属于合法的Java标识符是（）。

A．_cat B．5books C．+static D．-3.14159．在Java中，由Java编译器自动导入，而无需在程序中用import导入的包是（）。

A．java.applet B．java.awt C．java.util D．ng．构造方法的调用方式中，正确的是（）。

A．按照一般方法调用B．由用户直接调用C．只能通过new自动调用D．被系统调用．在Java中，能实现多重继承效果的方式是（）。

A．内部类B．适配器C．接口D．同步．下列选项中，与成员变量共同构成一个类的是（）。

A．关键字B．方法C．运算符D．表达式．用于在子类中调用被重写父类方法的关键字是（）。

A．this B．super C．This D．Super．在Java语言中，如果你有下面的类定义：abstract class Shape {abstract void draw();}class Square extends Shape{ }如果你试图编译上面的代码会发生（）。

java中List对象排序通⽤⽅法本⽂实例讲述了java中List对象排序通⽤⽅法。

分享给⼤家供⼤家参考。

具体分析如下：在数据库中查出来的列表list中，往往需要对不同的字段重新排序，⼀般的做法都是使⽤排序的字段，重新到数据库中查询。

如果不到数据库查询，直接在第⼀次查出来的list中排序，⽆疑会提⾼系统的性能。

只要把第⼀次查出来的结果存放在session中，就可以对list重新排序了。

⼀般对list排序可以使⽤Collections.sort(list)，但如果list中包含是⼀个对象的话，这种⽅法还是⾏不通的。

那要怎么排序呢？如果有⼀个UserInfo对象,包含如下字段：private ng.Integer userId;private ng.String username;private java.util.Date birthDate;private ng.Integer age;那么现在要对userId排序，你可能会使⽤下⾯的⽅法：Collections.sort(list, new Comparator() {public int compare(Object a, Object b) {int one = ((Order)a).getUserId ();int two = ((Order)b).getUserId ();return one- two ;}});这样，如果要实现对UserInfo列表各字段排序，是不是每个字段都写⼀段如上所⽰的代码呢？那当然不是我们所需要的结果。

写程序要写得越来越精练，不能越写越冗余。

能不能写⼀个通⽤的⽅法呢？答案是肯定的，但⾸先必须能解决下⾯三个问题：1．可以使⽤泛型；2．能够使⽤通⽤的⽐较⽅法，⽐如compareTo；3．有没有类似泛型、泛型⽅法那样的泛⽅法？第1个问题可以解决，第2个问题难度也不是很⼤，因为Java所有的类型都继承于Object，都有⼀个ToString的⽅法，暂且可以把所有类型转换成String，然后⽤compareTo作⽐较。

实验1 简单Java程序调试✧基本题1）编写一个程序输出如下图案****** ************* *** ********* ** ****** ** ****** ** ****** ** ************ ** ** ****** ** ** ****** ** ** ********* **************2)编制applet程序，绘制一个长120、宽80的红色矩形，并在矩形内部绘制一个兰色内切椭圆。

✧提高题1）编写一个应用程序绘制一个如下的操作菜单。

*****************************| 1. 增加1个学生 || 2. 显示所有学生 || 3. 退出程序 || 请输入选择（1-3）： |*****************************2）创建一个applet程序，绘制两个同心圆，园心显示“同心”两个汉字。

实验2 分支、循环程序设计✧基本题1）从键盘输入4个学生的成绩，找出最高分和最低分。

【提示】引入两个变量分别存放最高分和最低分，根据比较改变这两个变量值。

2）写一个程序输入一个整数n,输出相应三角形。

例如：N=4，则三角形如下：##########3）编写一个程序，用于输出Fibonacci数列的前20项。

4)输入一个百分制分数，输出其对应的五分制成绩，包括：优、良、中、及格、不及格。

5) 计算算式： 1-1/2+1/3-1/4+1/5-…-1/1006)输出九九乘法表,格式如下:1*1=1 1*1=2 1*3=3 ……2*1=1 2*2=2 2*3=3 …………9*1=1 9*2=18 9*3=27 ……✧提高题1）设有一元二次方程如下：aX2+bx+c=0试根据从键盘输入的a，b，c求解方程的根。

【提示】要考虑各种情形：一是a为0的情形，方程根为-c/b。

还有就是根据判别式Δ=b2 - 4ac进行判断，如果Δ.>0有两个实根；Δ=0，有一个实根；Δ<0，无实数解。

最经典java习题答案一、简单编程1.编写程序使用方法重载分别实现了两个和三个整数的相加。

public class ADD{int a;int b;int c;public int Add(int a,int b){return a+b;}public int Add(int a,int b,int c){return a+b+c;}}public class program_1 {public static void main(String[] args) {ADD x=new ADD();System.out.println(x.Add(13, 15));System.out.println(x.Add(13, 15,17));}}结果：2.编写程序使用冒泡法对一组数进行排序public class Sort {int a[];public void px(int b[]){a=b;}public void make(){int temp=0;for(int i=0;i<a.length-1;i++){for(int j=i+1;j<a.length;j++){if(a[j]>a[i]){temp=a[j];a[j]=a[i];a[i]=temp;}}}}public void printout(){for(int i=0;i<a.length;i++){System.out.print(a[i]+"\t");}}}public class program_2 {public static void main(String[] args) {Sort x=new Sort();int b[]={1,7,5,4,8,6,2,9,0};x.px(b);x.make();x.printout();}}结果：3．定义一个线程PrintThread，该线程打印输出1～1000之间所有3的倍数，每输出一个数休眠1500毫秒，在main方法中创建该线程的一个实例，并启动该线程。

Java的List集合按照对象的多个属性排序public class Employee {private int level;private int salary;private int years;public int getLevel() {return level;}public void setLevel(int level) {this.level = level;}public int getSalary() {return salary;}public void setSalary(int salary) {this.salary = salary;}public int getYears() {return years;}public void setYears(int years) {this.years = years;}@Overridepublic String toString() {return "Employee [level=" + level + ", salary=" + salary + ", years="+ years + "]";}}public class MainActivity extends AppCompatActivity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_main);List<Employee> list = new ArrayList<Employee>();Employee e = new Employee();e.setLevel(1);e.setSalary(300);e.setYears(4);list.add(e);e = new Employee();e.setLevel(1);e.setSalary(500);e.setYears(4);list.add(e);e = new Employee();e.setLevel(2);e.setSalary(500);e.setYears(4);list.add(e);e = new Employee();e.setLevel(1);e.setSalary(300);e.setYears(5);list.add(e);// Collections.sort(list, new Comparator<Employee>() {// public int compare(Employee e2, Employee e1) {// int a = e1.getLevel() - e2.getLevel();// if (a != 0) {// return a > 0 ? -1 : 1;// }// a = e1.getSalary() - e2.getSalary();// if (a != 0) {// return a > 0 ? -1 : 1;// }// a = e1.getYears() - e2.getYears();// return a > 0 ? -1 : 1;// }// });Collections.sort(list, new Comparator<Employee>() { public int compare(Employee e1, Employee e2) { int a = e1.getLevel() - e2.getLevel();if (a != 0) {return a > 0 ? 1 : -1;}a = e1.getSalary() - e2.getSalary();if (a != 0) {return a > 0 ? 1 : -1;}a = e1.getYears() - e2.getYears();return a > 0 ? 1 : -1;}});// Employee [level=2, salary=500, years=4]// Employee [level=1, salary=500, years=4]// Employee [level=1, salary=300, years=5]// Employee [level=1, salary=300, years=4]// Employee [level=1, salary=300, years=4]// Employee [level=1, salary=300, years=5]// Employee [level=1, salary=500, years=4]// Employee [level=2, salary=500, years=4]// [level=1, salary=300, years=4]// [level=1, salary=300, years=5]// [level=1, salary=500, years=4]// [level=2, salary=500, years=4]for (Employee em : list) {System.out.println(em);}}}。

汇编语⾔输⼊10个数排序并输出的实现⼀：题⽬描述在键盘输⼊任意10个数1. 按从⼩到⼤排序后，在计算机屏幕上先输出来。

要有结果提⽰（字符串显⽰）。

2. 将10个数做累加，结果在计算机屏幕显⽰累加和。

⼆：伪指令的定义1.数据段ATAS SEGMENTstring_1 DB 'Please input a numbers(0-65536):','$'string_2 DB 'ERROR: OVERFLOW! Please input again:','$'string_3 DB 'The array you have input is:',0ah,0dh,'$'string_4 DB 'After Sort the num is:',0ah,0dh,'$'string_5 DB ' ','$'DATA DW 10 DUP(?)massege DB 'The sum of the array is: ',0ah,0DH,'$'DATAS ENDS说明：string_1输⼊范围提⽰string_2输⼊错误提⽰string_3输出原数组提⽰string_4输出排序后数组提⽰string_5空格符DATA缓冲区数组2.堆栈段STACKS SEGMENTDW 256 dup(?)STACKS ENDS3.代码段CODES SEGMENTASSUME CS:CODES,DS:DATAS,SS:STACKS三：模块分解与实现1. DOS输⼊10个数字输⼊10个⽆符号数存⼊缓冲区，并且保证 num&lt;65536num &lt; 65536num<65536为何输⼊范围是65536呢⼀个字的最⼤表⽰范围是 FFFFFFFFFFFF 其在⼗进制的表⽰下为 65535HEX FFFFDEC65535BIN1111 1111 1111 11111.1 输⼊函数⼦程序;---------输⼊函数（单数字输⼊）------------Input PROC Nearpush AXpush BXpush CXpush DX;---------输⼊提⽰--------------MOV BX, 0CLCMOV DX, 0;----------输⼊数字--------------Lp_0:MOV AH, 1INT 21HCMP AL, 20H ;回车JE L_CRLF;----- x belong to [0,9] ----------SUB AL, 30H ; ASCII -> intJL L_ERRORCMP AL, 9JG L_ERROR;------- string -> int -----------MOV AH, 0 ;将 AL扩展成 AXXCHG AX, BX ;保护 AX值MOV CX, 10MUL CX ; bx *= 10ADD AX , BXJC L_ERROR ; OVERFLOW处理XCHG AX, BXJMP Lp_0L_ERROR:MOV DX, 0MOV BX, 0CALL CRLF ; 换⾏CALL ERROR ; 输出错误提⽰JMP Lp_0L_CRLF: ; 以换⾏作为⼀个数的结束标志MOV DX, 0MOV DATA[SI], BX ;解析函数功能：本质类似于⾼精度计算，将读⼊的⼀个串转成数字存储在DATA数组中分成三⼤部分⼀：输⼊提⽰⼆：错误判断及提⽰三：转化为数字L_ERROR 错误处理L_CRLF 结束处理我们来举⼀个123412341234 的例⼦Register1234AX1234BX0112123CX10101010AX+(BX∗CX)AX + (BX * CX)AX+(BX∗CX)最后将结果存储在DATA数组⾥2.实现冒泡排序冒泡排序作为⼀个简单的排序算法，时间复杂度 O(n2)O(n^2)O(n2) 需要两层循环，为了提⾼代码的可读性，我们将内层的循环写成⼀个⼦程序每次调⽤内层循环很简单，每次从头⽐到尾，遇到⽐它⼩的交换就可以了。

javaCollections排序--多条件排序实例我就废话不多说了，⼤家还是直接看代码吧~// 告警排序Collections.sort(domesticAirport, comparator);// 告警排序Comparator<AirportRtWeatherWarningBeanForTable> comparator = new Comparator<AirportRtWeatherWarningBeanForTable>() { @Overridepublic int compare(AirportRtWeatherWarningBeanForTable a1, AirportRtWeatherWarningBeanForTable a2) {// ⾸先根据是否过期排序if(a1.isMetarExpired() && !a2.isMetarExpired()){return 1;}else if (!a1.isMetarExpired() && a2.isMetarExpired()) {return -1;} else if ((a1.isMetarExpired() && a2.isMetarExpired()) || (!a1.isMetarExpired() && !a2.isMetarExpired())) {//同时过期，或者都不过期，则按告警类型排序if (a1.getWarningColor() != a2.getWarningColor()) {return compareColor(a1.getWarningColor(), a2.getWarningColor());}}//告警类型相同，按字母排序return a1.getCode4().compareTo(a2.getCode4());}};// 告警类型⽐较排序public int compareColor(Color color1, Color color2) {int i = 0;int j = 0;if (color1.equals(MeteoWeatherWarningPanel.RED)) {i = 3;} else if (color1.equals(MeteoWeatherWarningPanel.YELLOW)) {i = 2;} else if (color1.equals(MeteoWeatherWarningPanel.GREEN)) {i = 1;}if (color2.equals(MeteoWeatherWarningPanel.RED)) {j = 3;} else if (color2.equals(MeteoWeatherWarningPanel.YELLOW)) {j = 2;} else if (color2.equals(MeteoWeatherWarningPanel.GREEN)) {j = 1;}int k = i - j;if (k > 0) {return -1;} else if (k < 0) {return 1;} elsereturn 0;}补充知识：Collections.sort多字段排序-指定排序⽅式-指定排序字段看代码吧~1、创建需要排序的字段数组String [] sortNameArr = {“one”, “tow”,“startDate”};2、为每个字段执⾏排序规则boolean[] isAs = {false, false, false};3、重写sort⽅法进⾏排序ListUtils.sort(list, sortNameArr, isAs);public static <E> void sort(List<E> list, final String[] sortnameArr, final boolean[] typeArr) {if (sortnameArr.length != typeArr.length) {throw new RuntimeException("属性数组元素个数和升降序数组元素个数不相等");}Collections.sort(list, new Comparator<E>() {public int compare(E a, E b) {int ret = 0;try {for (int i = 0; i < sortnameArr.length; i++) {ret = pareObject(sortnameArr[i], typeArr[i], a, b);if (0 != ret) {break;}}} catch (Exception e) {e.printStackTrace();}return ret;}});}private static <E> int compareObject(final String sortname, final boolean isAsc, E a, E b) throws Exception { int ret;Object value1 = ListUtils.forceGetFieldValue(a, sortname);Object value2 = ListUtils.forceGetFieldValue(b, sortname);// 两个字段都不为空进⾏排序if (null != value1 && null != value2) {String str1 = value1.toString();String str2 = value2.toString();if (value1 instanceof Number && value2 instanceof Number) {int maxlen = Math.max(str1.length(), str2.length());str1 = ListUtils.addZero2Str((Number) value1, maxlen);str2 = ListUtils.addZero2Str((Number) value2, maxlen);} else if (value1 instanceof Date && value2 instanceof Date) {// ⽇期排序long time1 = ((Date) value1).getTime();long time2 = ((Date) value2).getTime();int maxlen = Long.toString(Math.max(time1, time2)).length();str1 = ListUtils.addZero2Str(time1, maxlen);str2 = ListUtils.addZero2Str(time2, maxlen);}if (isAsc) {ret = pareTo(str2);} else {ret = pareTo(str1);}return ret;} else if (null == value1 && null != value2) {// ⽐值为空被⽐值⼤ret = 1;} else {// 被⽐值为空⽐值打ret = -1;}return ret;}public static String addZero2Str(Number numObj, int length) {NumberFormat nf = NumberFormat.getInstance();// 设置是否使⽤分组nf.setGroupingUsed(false);// 设置最⼤整数位数nf.setMaximumIntegerDigits(length);// 设置最⼩整数位数nf.setMinimumIntegerDigits(length);return nf.format(numObj);}public static Object forceGetFieldValue(Object obj, String fieldName) throws Exception {Field field = obj.getClass().getDeclaredField(fieldName);Object object = null;boolean accessible = field.isAccessible();if (!accessible) {// 如果是private,protected修饰的属性，需要修改为可以访问的field.setAccessible(true);object = field.get(obj);// 还原private,protected属性的访问性质field.setAccessible(accessible);return object;}object = field.get(obj);return object;}以上这篇java Collections 排序--多条件排序实例就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。