java算法数组
读取数组元素，加一判断数组两个是否相等，相等直接输出，不等，换行输出。直到数组内所有元素都比完，程序结束。
Ⅱ java 数组录入排序算法
//给你写了个新的
//给点财富鼓励一下，ok？
import java.util.Arrays;
import java.util.Scanner;
public class lianxi
{
public static void main(String[] args)
{
int capacity=16,count=0;
int[] arr=new int[capacity];
Scanner sc=new Scanner(System.in);
String s=null;
System.out.println("请输入要排序的数据，输入exit结束：");
while(true)
{
s=sc.nextLine();
if(null!=s)
{
if(s.equals("exit"))
{
break;
}
else if(count+1>=capacity)
{
capacity*=2;
arr=Arrays.Of(arr,capacity);
}
arr[count++]=Integer.parseInt(s);
}
}
Arrays.sort(arr,0,count);
System.out.println("min="+arr[0]);
System.out.println("max="+arr[count-1]);
}
}
Ⅲ java数组算法 求高手解答..
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class DuAry {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<String, Integer>();
String[][] string={{"A","1"},{"A","2"},{"B","3"},{"B","4"}};
for(int i = 0; i < string.length; i++){
String[] ary = string[i];
String cract = ary[0].trim();
if(map.containsKey(cract)){
map.put(cract,new Integer(map.get(cract).intValue() + Integer.parseInt(ary[1].trim())));
}else{
map.put(cract, new Integer(ary[1].trim()));
}
}
Iterator<Map.Entry<String, Integer>> ite = map.entrySet().iterator();
while(ite.hasNext()){
Map.Entry<String, Integer> entry = ite.next();
System.out.println(entry.getKey() + "\t" + entry.getValue());
}
}
}
-------------testing
B 7
A 3
--------------------算法2：
import java.util.ArrayList;
import java.util.List;
public class DuArray2 {
public static void main(String[] args) {
String[][] string={{"A","1"},{"A","2"},{"B","3"},{"B","4"}};
List<Item> list = new ArrayList<Item>();
for(String[] ary: string){
String key = ary[0];
String value = ary[1];
boolean isFound = false;
for(Item item: list){
if(item.getKey().equals(key)){
item.add(Integer.parseInt(value));
isFound = true;
break;
}
}
if(!isFound){
list.add(new Item(key, Integer.parseInt(value)));
}
}
for(Item item: list){
System.out.println(item.toString());
}
}
}
class Item{
private String key;
private Integer value;
public Item(String key, Integer value){
this.key = key;
this.value = value;
}
public void add(int num){
this.value = new Integer(this.value.intValue() + num);
}
public String getKey() {
return key;
}
public String toString(){
return key + "\t" + value;
}
}
-----------testing result
A 3
B 7
Ⅳ Java的数组的几种经典算法
JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。
快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。
冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。
选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。
插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。
<1>利用Arrays带有的排序方法快速排序
public class Test2{ public static void main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } }
<2>冒泡排序算法
public static int[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;i<args.length-1;i++){ for(int j=i+1;j<args.length;j++){ if (args[i]>args[j]){ int temp=args[i]; args[i]=args[j]; args[j]=temp; } } } return args; }
<3>选择排序算法
public static int[] selectSort(int[] args){//选择排序算法 for (int i=0;i<args.length-1 ;i++ ){ int min=i; for (int j=i+1;j<args.length ;j++ ){ if (args[min]>args[j]){ min=j; } } if (min!=i){ int temp=args[i]; args[i]=args[min]; args[min]=temp; } } return args; }
<4>插入排序算法
public static int[] insertSort(int[] args){//插入排序算法 for(int i=1;i<args.length;i++){ for(int j=i;j>0;j--){ if (args[j]<args[j-1]){ int temp=args[j-1]; args[j-1]=args[j]; args[j]=temp; }else break; } } return args; }
Ⅳ JAVA数组的几种算法能不能用通俗易懂的意思介绍一下
数组主要是排序。插入排序相当于玩扑克牌排序一次排序拿到数字直接插入最终位置，冒泡排序就想是烧开水一样没次排序把大的向上排序，（或者小的向上），快速排序就是找到一个中间的左边一定比他小右边一定比他大之后对左右继续这种算法。排序就这么多还有啥算法暂时想不起来了你主要想问啥呢？
Ⅵ java数组的方法
1.;创建数组 1)先声明,再用new进行内存分配 int arr[]; //一维数组 ...
2.;初始化 //一维数组 int arr1[] = new int[]{1,2,3,4,5...
3.;数组的基本操作 1)遍历数组时,foreach语句更简单 2)对数组元素进行替换--...
4.;对数组进行排序---Arrays类就静态sort()方法-----可对任意类型数组...
5.;复制数组 1)Of()方法---复制数组至指定长度----开辟新的内存空间,原...
Ⅶ java数组和算法的问题
arr[arr.length-1]=num;
43在这句的时候被num替换掉了
java的数组长度被初始化之后就是固定的
如果你想象里面加入一个新值
需要重新定义数组，也就是说如果oldarr.length
=
5
你想象中见放第六个数是办不到的
只能重新定义数据
int[]
newarr
=
new
int[oldarr+1]
这么来弄
Ⅷ java怎么让数组的数字从大到小排序
将数字从大到小排序的方法：
例如简一点的冒泡排序，将第一个数字和后面的数字逐个比较大小，如果小于，则互换位置，大于则不动。此时，第一个数为数组中的最大数。然后再将第二个数与后面的数逐个比较，以次类推。
示例代码如下：
publicclassTest{
publicstaticvoidmain(String[]args){
int[]array={12,3,1254,235,435,236,25,34,23};
inttemp;
for(inti=0;i<array.length;i++){
for(intj=i+1;j<array.length;j++){
if(array[i]<array[j]){
temp=array[i];
array[i]=array[j];
array[j]=temp; //两个数交换位置
}
}
}
for(inti=0;i<array.length;i++){
System.out.print(array[i]+"");
}
}
}
数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。
Java 语言中提供的数组是用来存储固定大小的同类型元素。
你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99
(8)java算法数组扩展阅读
Java中利用数组进行数字排序一般有4种方法：
1、选择排序是先将数组中的第一个数作为最大或最小数，然后通过循环比较交换最大数或最小数与一轮比较中第一个数位置进行排序。
2、冒泡排序也是先将数组中的第一个数作为最大或最小数，循环比较相邻两个数的大小，满足条件就互换位置，将最大数或最小数沉底。
3、快速排序法主要是运用Arrays类中的Arrays.sort方法（）实现。
4、插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。
Ⅸ java常用算法,给个int数组,数字不连续,找出最小空缺数
public static void main(String[] args) {
int[] array = new int[] {1,2,3,6,7,8,9,10,11,12, 13, 14, 15, 16, 17, 18, 19, 20 };
//将数组拆分
int minque = 1;
if (1 == array[0]){
minque = zhaoque(array);
}
System.out.println(minque);
}
public static int zhaoque(int[] array){
int minque = 1;
//array 不为空
if (null != array && array.length>0){
if (array.length == 1){
minque = array[0]+1;
} else if(array.length == 2){
if (1 == (array[1] - array[0])){
minque = array[1]+1;
} else {
minque = array[0]+1;
}
} else {
int headlength = (array.length+1)/2;
int[] headArray = new int[headlength];
System.array(array,0,headArray,0,headlength);
//检查前半部分是否密集
int headmin = headArray[0];
int headmax = headArray[headlength-1];
if (headlength > (headmax - headmin)){
//前部分密集分布
int footlength = array.length - headlength;
int[] footArray = new int[footlength];
System.array(array,headlength,footArray,0,footlength);
int footmin = footArray[0];
int footmax = footArray[footlength-1];
// 检查后部分是否与前部分衔接
if (1 == (footmin - headmax)){
//检查后部分是否密集
if (footlength > (footmax - footmin)){
//后半部分密集分布
minque = footmax +1;
} else {
minque = zhaoque(footArray);
}
} else {
minque = headmax +1;
}
} else {
minque = zhaoque(headArray);
}
}
}
return minque;
}
Ⅹ java 算法数组（4，6，8，9，10，12，14，15，16，18，20，21，22，24，
importjava.util.Arrays;
importjava.util.LinkedList;
publicclassTest
{
publicstaticvoidrecursionSub(LinkedList<String[]>list,intcount,String[]array,intind,
intstart,int...indexs)
{
start++;
if(start>count-1)
{
return;
}
if(start==0)
{
indexs=newint[array.length];
}
for(indexs[start]=ind;indexs[start]<array.length;indexs[start]++)
{
recursionSub(list,count,array,indexs[start]+1,start,indexs);
if(start==count-1)
{
String[]temp=newString[count];
for(inti=count-1;i>=0;i--)
{
temp[start-i]=array[indexs[start-i]];
}
list.add(temp);
}
}
}
publicstaticvoidmain(String[]args)
{
Stringstring="4,6,8,9,10,12,14,15,16,18,20,21,22,24,25,26,27,28,30,32,33";
String[]A=string.split(",");
LinkedList<String[]>list=newLinkedList<String[]>();
recursionSub(list,4,A,0,-1);
for(String[]strings:list)
{
intsum=0;
for(inti=0;i<strings.length;i++)
{
inta=Integer.parseInt(strings[i]);
sum+=a;
}
if(sum>=80&&sum<90)
{
System.out.println(Arrays.toString(strings).replaceAll(",\s","+")+"="+sum);
}
}
}
}