java数组的常用方法

A. 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; }

B. javaarraylist的方法有哪些

方法摘要

boolean add(E e)
将指定的元素添加到此列表的尾部。
void add(int index, E element)
将指定的元素插入此列表中的指定位置。
boolean addAll(Collection<? extends E> c)
按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
boolean addAll(int index, Collection<? extends E> c)
从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。
void clear()
移除此列表中的所有元素。
Object clone()
返回此 ArrayList 实例的浅表副本。
boolean contains(Object o)
如果此列表中包含指定的元素，则返回 true。
void ensureCapacity(int minCapacity)
如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
E get(int index)
返回此列表中指定位置上的元素。
int indexOf(Object o)
返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
boolean isEmpty()
如果此列表中没有元素，则返回 true
int lastIndexOf(Object o)
返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
E remove(int index)
移除此列表中指定位置上的元素。
boolean remove(Object o)
移除此列表中首次出现的指定元素（如果存在）。
protected void removeRange(int fromIndex, int toIndex)
移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
E set(int index, E element)
用指定的元素替代此列表中指定位置上的元素。
int size()
返回此列表中的元素数。
Object[] toArray()
按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
<T> T[] toArray(T[] a)
按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
void trimToSize()
将此 ArrayList 实例的容量调整为列表的当前大小。

从类 java.util.AbstractList 继承的方法

equals, hashCode, iterator, listIterator, listIterator, subList

从类 java.util.AbstractCollection 继承的方法

containsAll, removeAll, retainAll, toString

从类 java.lang.Object 继承的方法

finalize, getClass, notify, notifyAll, wait, wait, wait

从接口 java.util.List 继承的方法

containsAll, equals, hashCode, iterator, listIterator, listIterator, removeAll, retainAll, subList

C. java中数组赋值的方法是什么

public class TempArray {

public static void main(String[] args) {

//声明数值型数组

int[] array = {1, 2};

int[] array2 = new int[4];

//新增一个数组长度

array = Arrays.Of(array, array.length+1);

//将3这个数值赋值个数组索引 2 的位置，也就是最后面追加

array[array.length-1] = 3;

System.out.println(array2.length); //Result: 4

上面用的是数组，你也可以用 ArrayList 数组列表，是List的一个实现。

D. Java中数组的定义与使用方法

Java中数组的定义与使用方法:
1、数组的定义
语法有两种：
type arrayName[];
type[] arrayName;
type 为Java中的任意数据类型，包括基本类型和组合类型，arrayName为数组名，必须是一个合法的标识符，[ ] 指明该变量是一个数组类型变量。
例如：
int demoArray[];
int[] demoArray;
这两种形式没有区别，使用效果完全一样，读者可根据自己的编程习惯选择。
注意：Java在定义数组时并不为数组元素分配内存，因此[ ]中无需指定数组元素的个数，即数组长度。而且对于如上定义的一个数组是不能访问它的任何元素的，开发者必须要为它分配内存空间，这时要用到运算符new，其格式如下：
arrayName=new type[arraySize];
其中，arraySize 为数组的长度，type 为数组的类型。如：
demoArray=new int[3];//为一个整型数组分配3个int 型整数所占据的内存空间。
2、数组的初始化
可以在声明数组的同时进行初始化（静态初始化），也可以在声明以后进行初始化（动态初始化）。例如：
// 静态初始化
// 静态初始化的同时就为数组元素分配空间并赋值
int intArray[] = {1,2,3,4};
String stringArray[] = {"", "", "网络知道"};
// 动态初始化
float floatArray[] = new float[3];
floatArray[0] = 1.0f;
floatArray[1] = 132.63f;
floatArray[2] = 100F;

3、数组的使用：
每个数组都有一个length属性来指明它的长度，例如 intArray.length 指明数组 intArray 的长度。
【示例】写一段代码，要求输入任意5个整数，输出它们的和。
import java.util.*;
public class Demo {
public static void main(String[] args){
int intArray[] = new int[5];
long total = 0;
int len = intArray.length;

// 给数组元素赋值
System.out.print("请输入" + len + "个整数，以空格为分隔：");
Scanner sc = new Scanner(System.in);
for(int i=0; i<len; i++){
intArray[i] = sc.nextInt();
}

// 计算数组元素的和
for(int i=0; i<len; i++){
total += intArray[i];
}

System.out.println("所有数组元素的和为：" + total);
}
}

运行结果：
请输入5个整数，以空格为分隔：10 20 15 25 50
所有数组元素的和为：120

E. Java定义一个一维数组有哪几种方法

首先: 一维数组的声明 ; 代码如下

int[]ary1;//Java推荐的数组声明方式

intary2[];//不推荐,但也是正确的,C语言等使用这种方式

其次: 声明的声明和赋值

	//参考一
	int[]ary1={1,2,3};//声明的时候,同时赋值
	//参考二	
	int[]ary2=newint[3];//指定数组的长度为3
		ary2[0]=1;//数组下标从0开始,依次给每个元素赋值
		ary2[1]=2;
		ary2[2]=3;
	//参考三	
	int[]ary3=newint[]{1,2,3};//注意,这里的newint[]方框里不能指定长度

最后: 注意数组的默认值;

简单数据类型,比如boolean类型的数组,默认值就是false, int类型的数组,默认值就是0.
对象类型的数组,比如Boolean类型的数组,默认值是null,Integer类型的数组,默认值还是null

int[]ary1=newint[1];
System.out.println(ary1[0]);//输出0
		
Integer[]ary2=newInteger[1];
System.out.println(ary2[0]);//输出null
		
boolean[]b1=newboolean[1];
System.out.println(b1[0]);//输出false
		
Boolean[]b2=newBoolean[1];
System.out.println(b2[0]);//输出null

F. java怎么查找数组的所有方法

不知道你实际是不是指ArrayList这个类,下面打印ArrayList类的所有方法

Method[]methods=ArrayList.class.getMethods();
for(inti=0;i<methods.length;i++){
System.out.print(methods[i].getReturnType());
System.out.print("");
System.out.print(methods[i].getName());
System.out.print("(");
Class<?>[]parameterTypes=methods[i].getParameterTypes();
for(intj=0;j<parameterTypes.length;j++){
System.out.print(parameterTypes[j].getName());
if(j<parameterTypes.length-1){
System.out.print(",");
}
}
System.out.println(")");
}

[Ljava.lang.Object; [L标示数组

G. Java中创建数组的几种方法

Java中创建对象的四种方法 收藏Java中创建对象的四种方式
1.用new语句创建对象，这是最常见的创建对象的方法。
2.运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
3.调用对象的clone()方法。
4.运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。
第一种最常见

H. java中数组有没有length()方法string没有lenght()方法

java中数组是没有length()方法的，只有length属性，数组array.length返回的是该数组的长度。

字符串String是有length()方法的，str.length()返回的是该字符串的长度。

(8)java数组的常用方法扩展阅读

java数组常用方法：

1、声明一个数组

String[] aArray = new String[5]；

String[] bArray = {"a","b","c", "d", "e"}；

String[] cArray = new String[]{"a","b","c","d","e"}；

2、打印一个数组

String[] aArray = new String[5]；

String[] bArray = {"a","b","c", "d", "e"}；

String[] cArray = new String[]{"a","b","c","d","e"}；

3、根据数组创建ArrayList

String[] stringArray = { "a", "b", "c", "d", "e" }；

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray))；

System.out.println(arrayList)；

4、判断数组内部是否包含某个值

String[] stringArray = { "a", "b", "c", "d", "e" }；

boolean b = Arrays.asList(stringArray).contains("a")；

System.out.println(b)；

5、连接两个数组

int[] intArray = { 1, 2, 3, 4, 5 }；

int[] intArray2 = { 6, 7, 8, 9, 10 }；

int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2)；

6、声明一个内联数组

method(new String[]{"a", "b", "c", "d", "e"})

String常用方法：

1、求字符串某一位置字符

charAt(int index)返回字符串中指定位置的字符；注意字符串中第一个字符索引是0，最后一个是

length()-1。

例如：

String str = new String("asdfzxc")；

char ch = str.charAt(4)；//ch = z

2、提取子串

用String类的substring方法可以提取字符串中的子串，该方法有两种常用参数：

1)substring(int beginIndex)该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一

个新的字符串返回。

2)substring(int beginIndex, int endIndex)该方法从beginIndex位置起，从当前字符串中取出到

endIndex-1位置的字符作为一个新的字符串返回。

例如：

String str1 = new String("asdfzxc")；

String str2 = str1.substring(2)；//str2 = "dfzxc"

String str3 = str1.substring(2,5)；//str3 = "dfz"

3、字符串比较

1)compareTo(String anotherString)该方法是对字符串内容按字典顺序进行大小比较，通过返回的

整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负

整数，相等返回0。

2)compareToIgnore(String anotherString)与compareTo方法相似，但忽略大小写。

3)equals(Object anotherObject)//比较当前字符串和参数字符串，在两个字符串相等的时候返回

true，否则返回false。

4)equalsIgnoreCase(String anotherString)//与equals方法相似，但忽略大小写。

例如：

String str1 = new String("abc")；

String str2 = new String("ABC")；

int a = str1.compareTo(str2)；//a>0

int b = str1.compareToIgnoreCase(str2)；//b=0

boolean c = str1.equals(str2)；//c=false

boolean d = str1.equalsIgnoreCase(str2)；//d=true

4、字符串连接

concat(String str)将参数中的字符串str连接到当前字符串的后面，效果等价于"+"。

例如：

String str = "aa".concat("bb").concat("cc")；

相当于String str = "aa"+"bb"+"cc"；

I. Java数组的几种常用操作方法

int[] num = {5,4,3,2,1};
for(int i = 0; i < num.length - 1; i++) {
for (int j = i + 1; j < num.length; j++) {
if (num[i] > num[j]) {
int tmp = num[i];
num[i] = num[j];
num[j] = tmp;
}
}
System.out.print("排序后：" + num[i]);
}

J. java字符数组方面常用的函数

数组最主要的方法就是length,而其它的方法都是继承自Object类的,对于8大基本类型来说,你还可以使用数组的工具类Arrays，排序、查找、复制都有.