Java实例,对10个数进行排序
题44：编程输入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：求序列中所有递增或递减子序列的个数并输出子序列。
2、输入8个数,用冒泡法实现升序排列
第六次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获取十位随机数的方法
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排序的三种实现方法实例
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实现哈希排序算法是一种基于哈希表的排序算法，它利用哈希函数将元素映射到桶中，并通过对桶中的元素进行排序，最终得到有序的结果。
在本文中，我们将介绍哈希排序算法的原理，并给出其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种内部排序算法
⽤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. 希尔排序希尔排序⼜称缩⼩增量排序，其本质还是插⼊排序，只不过是将待排序列按某种规则分成⼏个⼦序列，然后如同前⾯的插⼊排序⼀般对这些⼦序列进⾏排序。
java3-1
4.方法
方法重载： 方法重载的意思是：一个类中可以有多个方法 具有相同的名字，但这些方法的参数必须不同。 或者是参数的个数不同，或者是参数的类型不 同。
class Area { float getArea(float r){ return 3.14f*r*r; } double getArea(float x,int y){ return x*y; }
double x; }
3.成员变量和局部变量 Example3_1_3.java
成员变量又分为实例 成员变量（简称实例 变量）和类变量（也 称静态变量） 。如果 成员变量的类型前面 加上关键字static，这 样的成员变量称做是 类变量或静态变量。
class People{ float a[ ]; static int boy;
void f(){ int boy; this.boy++; } }
4.方法
我们已经知道一个类的类体由两部分组成：变量的定 义和方法的定义。方法的定义包括两部分：方法声明 和方法体。 最基本的方法声明包括：方法返回的数据类型，方法 名和方法类型，以及参数。
方法类型 方法名(定义参数){ 方法体 }
3 2 1 0
101 76 39 32 4 21 34
101 76 39 32 4 34 21
101 76 39 32
101 76 39 34
不参与排序
34
4
32
4
21
21
冒泡排序
排序算法有多种，最简单的是冒泡排序。冒泡排序是一种借助交换进 行排序的方法。
6 第五趟5 升序 排序 4
3 2 1 0
Java生成随机字符串数组的实例详解
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() ⽅法判断集合中之前是否已存在相同的字符串（虽然概率很⼩）。