java定义arraylist

❶ java 中ArrayList的用法！

1、如何使用ArrayList
最简单的例子：
ArrayList List = new ArrayList();
for( int i=0;i <10;i++ ) //给数组增加10个Int元素
List.Add(i);
//..程序做一些处理
List.RemoveAt(5);//将第6个元素移除
for( int i=0;i <3;i++ ) //再增加3个元素
List.Add(i+20);
Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组

这是一个简单的例子，虽然没有包含ArrayList所有的方法，但是可以反映出ArrayList最常用的用法

2、ArrayList重要的方法和属性
1）构造器
ArrayList提供了三个构造器：
public ArrayList();
默认的构造器，将会以默认（16）的大小来初始化内部的数组
public ArrayList(ICollection);
用一个ICollection对象来构造，并将该集合的元素添加到ArrayList
public ArrayList(int);
用指定的大小来初始化内部的数组

2）IsSynchronized属性和ArrayList.Synchronized方法
IsSynchronized属性指示当前的ArrayList实例是否支持线程同步，而ArrayList.Synchronized静态方法则会返回一个ArrayList的线程同步的封装。
如果使用非线程同步的实例，那么在多线程访问的时候，需要自己手动调用lock来保持线程同步，例如：
ArrayList list = new ArrayList();
//...
lock( list.SyncRoot ) //当ArrayList为非线程包装的时候，SyncRoot属性其实就是它自己，但是为了满足ICollection的SyncRoot定义，这里还是使用SyncRoot来保持源代码的规范性
{
list.Add( “Add a Item” );
}

如果使用ArrayList.Synchronized方法返回的实例，那么就不用考虑线程同步的问题，这个实例本身就是线程安全的，实际上
ArrayList内部实现了一个保证线程同步的内部类，ArrayList.Synchronized返回的就是这个类的实例，它里面的每个属性都是用
了lock关键字来保证线程同步。

3）Count属性和Capacity属性
Count属性是目前ArrayList包含的元素的数量，这个属性是只读的。
Capacity属性是目前ArrayList能够包含的最大数量，可以手动的设置这个属性，但是当设置为小于Count值的时候会引发一个异常。

4）Add、AddRange、Remove、RemoveAt、RemoveRange、Insert、InsertRange
这几个方法比较类似
Add方法用于添加一个元素到当前列表的末尾
AddRange方法用于添加一批元素到当前列表的末尾
Remove方法用于删除一个元素，通过元素本身的引用来删除
RemoveAt方法用于删除一个元素，通过索引值来删除
RemoveRange用于删除一批元素，通过指定开始的索引和删除的数量来删除
Insert用于添加一个元素到指定位置，列表后面的元素依次往后移动
InsertRange用于从指定位置开始添加一批元素，列表后面的元素依次往后移动

另外，还有几个类似的方法：
Clear方法用于清除现有所有的元素
Contains方法用来查找某个对象在不在列表之中

其他的我就不一一累赘了，大家可以查看MSDN，上面讲的更仔细
5）TrimSize方法
这个方法用于将ArrayList固定到实际元素的大小，当动态数组元素确定不在添加的时候，可以调用这个方法来释放空余的内存。
6）ToArray方法
这个方法把ArrayList的元素Copy到一个新的数组中。
3、ArrayList与数组转换
例1：
ArrayList List = new ArrayList();
List.Add(1);
List.Add(2);
List.Add(3);

Int32[] values = (Int32[])List.ToArray(typeof(Int32));

例2：
ArrayList List = new ArrayList();
List.Add(1);
List.Add(2);
List.Add(3);

Int32[] values = new Int32[List.Count];
List.CopyTo(values);

上面介绍了两种从ArrayList转换到数组的方法

例3：
ArrayList List = new ArrayList();
List.Add( “string” );
List.Add( 1 );
//往数组中添加不同类型的元素

object[] values = List.ToArray(typeof(object)); //正确
string[] values = (string[])List.ToArray(typeof(string)); //错误

和数组不一样，因为可以转换为Object数组，所以往ArrayList里面添加不同类型的元素是不会出错的，但是当调用ArrayList方法的时候，要么传递所有元素都可以正确转型的类型或者Object类型，否则将会抛出无法转型的异常。

❷ java中Arraylist是干什么的怎么用

java中的ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本。

它提供了如下一些好处：动态的增加和减少元素实现了ICollection和IList接口灵活的设置数组的大小 。

ArrayList 的用法：

ArrayList List = new ArrayList(); for( int
i=0;i<10;i++ ) //

给数组增加10个Int元素 List.Add(i); //..

程序做一些处理
List.RemoveAt(5);//

将第6个元素移除 for( int i=0;i<3;i++ ) //

再增加3个元素
List.Add(i+20); Int32[] values =
(Int32[])List.ToArray(typeof(Int32));//

返回ArrayList包含的数组 。

(2)java定义arraylist扩展阅读：

Arraylist的定义：

List 接口的大小可变数组的实现，位于API文档的java.util.ArrayList<E>。

实现了所有可选列表操作，并允许包括 null 在内的所有元素。

除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）

size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。

add 操作以分摊的固定时间 运行，也就是说，添加 n 个元素需要 O(n) 时间。

其他所有操作都以线性时间运行（大体上讲）。

与用于 LinkedList 实现的常数因子相比，此实现的常数因子较低。

每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。

它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。

并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单

在添加大量元素前，应用程序可以使用
ensureCapacity 操作来增加 ArrayList
实例的容量。这可以减少递增式再分配的数量。

注意，此实现不是同步的。如果多个线程同时访问一个 ArrayList
实例，而其中至少一个线程从结构上修改了列表，那么它必须 保持外部同步。

（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）

这一般通过对自然封装该列表的对象进行同步操作来完成。

如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问：

List list = Collections.synchronizedList(new ArrayList(...));

此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的。

在创建迭代器之后，除非通过迭代器自身的
remove 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出
。

因此，面对并发的修改，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

注意，迭代器的快速失败行为无法得到保证。

因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出

。

因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：迭代器的快速失败行为应该仅用于检测
bug。

❸ java如何动态创建ArrayList并给其赋值

1、ArrayList是动态数组，List是一个接口，不能实例化，需要实例化一个ArrayList；

List list = new ArrayList();
2、使用list .add(任何对象);就可以进行添加了。代码如下：

bean类
package com.whn.bean;

public class ListBean {
private String name;
private String pwd;

public void setName(String name) {
this.name = name;
}

public String getName() {
return name;
}

public void setPwd(String pwd) {
this.pwd = pwd;
}

public String getPwd() {
return pwd;
}
}

测试类package com.whn.test;

import com.whn.bean.ListBean;

import java.util.ArrayList;
import java.util.List;

public class ListTest {
//测试
public static void main(String[] args) {
List<ListBean> list = new ArrayList<ListBean>();//实例化一个arrayList
//添加
for(int i=10;i<20;i++){
ListBean listBean = new ListBean();
listBean.setName("name"+i);
listBean.setPwd("pwd"+i);
list.add(listBean);//把listBean添加到arrayList中
}

//把数据取出来
for(ListBean lb:list){
System.out.println(lb.getName());
System.out.println(lb.getPwd());
}

}
}

❹ java arraylist 用法

如果输出的全是整型的话可以使用下面这种方式

ArrayList<Integer>List=newArrayList<Integer>();
Integer[]num=newInteger[List.size()];
List.toArray(num);

如果输出的不确定那就得循环List一个一个给数组赋值了

❺ 安卓 JAVA定义Arraylist的一点小问题。求解决。

static ArrayList<BOOK> list = new ArrayList<BOOK>(); 把list 改成全局的
调用的时候直接类名.list 调用 这样你添加的地方 和取的地方才是同一个list

你前面那种做法 /这是另一个类实现增加功能，调用addBook方法往数组里面加了值。 增加的功能 new 了一个fangfa 调用list 添加了书籍

后面查询的时候 又new 了一个fangfa 这是2个对象不同的list

我猜你现在的情况是这样的

class fangfa {

ArrayList<BOOK> list = new ArrayList<BOOK>();

public fangfa() {
jia();
}

public void jia() {

}

public ArrayList<BOOK> getList() {
return list;
}

public void setList(ArrayList<BOOK> list) {
this.list = list;
}

public Boolean addBOOK(BOOK b) {

String id = b.getId();
for (int i = 0; i < list.size(); i++) {
BOOK book = list.get(i);
String id1 = book.getId();
if (id.equals(id1)) {
return false;
}
}
list.add(b);
return true;
}
}

class BOOK {

private String id;
private String name;
private String price;

public BOOK(String id, String name, String price) {
this.id = id;
this.name = name;
this.price = price;
}

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getPrice() {
return price;
}

public void setPrice(String price) {
this.price = price;
}
}

class addClass{
public void add(){
fangfa ff = new fangfa();
BOOK b = new BOOK("1","水浒","29");
ff.addBOOK(b);
}
}

public class Test{
public static void main(String args[]){
addClass ac = new addClass();
ac.add();
fangfa ff = new fangfa();
List<BOOK> list = ff.getList();

for(BOOK book:list){
System.out.println(book.getName());
}
}
}

static ArrayList<BOOK> list = new ArrayList<BOOK>(); 加上static 就可以得到了， 你可以自己试验一下

❻ Java ArrayList的使用

importjava.util.*;
classStudent{//定义学生类
	Stringname;
	Student(Stringname){//构造方法
		this.name=name;
	}
	//重写equals方法，保证只要名字相等，则认为是同一个人.
	publicbooleanequals(Objectobj){
		if(name==null||obj==null){
			returnfalse;
		}
		if(objinstanceofStudent){
			Studentsd=(Student)obj;
			returnname.equals(sd.name);
		}
		returnfalse;
	}
}
publicclasst2{
	publicstaticvoidmain(String[]args){
		Scannerreader=newScanner(System.in);
		Student[]stu=newStudent[4];//定义
		ArrayList<Student>stus=newArrayList<Student>();//ArrayList泛型，每个元素是1个学生。								
		System.out.println("输入4个学生姓名：");
		//初始化4个学生，并将他们添加进ArrayList
		for(inti=0;i<4;i++){
			stu[i]=newStudent(reader.nextLine());
			stus.add(stu[i]);
		}
		System.out.println("列表中还有"+stus.size()+"个学生：");
		for(inti=0;i<stus.size();i++){//遍历输出所有元素中学生的姓名
			System.out.println("第"+i+"个学生:"+stus.get(i).name);
		}
		//键盘输入一个学生姓名,判断该学生是否在列表中，如存在，则输出其在列表中的下标，然后将它从列表中移除。
		System.out.println("输入要查找的人的姓名：");
		Students=newStudent(reader.nextLine());
		if(stus.contains(s)){
			System.out.println("找到"+s.name+"，下标为"+stus.indexOf(s));//输出下标
			stus.remove(s);//从列表中移除该学生
			System.out.println("删除"+s.name+"后,还有"+stus.size()+"个学生：");
			for(inti=0;i<stus.size();i++){//遍历输出所有元素中学生的姓名
				System.out.println("第"+i+"个学生:"+stus.get(i).name);
			}
		}else
			System.out.println("列表中找不到"+s.name);//如不存在则输出找不到。
	}
}

效果

输入4个学生姓名：
天涯
明月
秋水
清泉
列表中还有4个学生：
第0个学生:天涯
第1个学生:明月
第2个学生:秋水
第3个学生:清泉
输入要查找的人的姓名：
天涯
找到天涯，下标为0
删除天涯后,还有3个学生：
第0个学生:明月
第1个学生:秋水
第2个学生:清泉

❼ 在java中如何定义一个字符串数组

1. java中定义一个字符串数组方式如下，string类型和其他基本类型相似，创建数组有两种方式：
String[] str={"AAA","BBB","CCC"};
String str[]={"AAA","BBB","CCC"};

2.推荐用ArrayList<String> strArray = new ArrayList<String> (); 比较灵活。

3.也可以写为如下格式：class[] array; array = new class[number];其中前半句为声明，后半句为初始化，初始化必须要让编译器知道大小，声明的时候java是不分配内存的，只有创建的时候也就是new的时候才会分配内存。

(7)java定义arraylist扩展阅读：

1.数组是相同数据类型的元素的集合。

2.数组中的各元素的存储是有先后顺序的，它们在内存中按照这个先后顺序连续存放在一起。

3.数组元素用整个数组的名字和它自己在数组中的顺序位置来表示。例如，a[0]表示名字为a的数组中的第一个元素，a[1]代表数组a的第二个元素，以此类推。

4.对于VB的数组，表示数组元素时应注意：下标要紧跟在数组名后，而且用圆括号括起来（不能用其他括号）。下标可以是常量，变量，或表达式，但其值必须是整数。下标必须为一段连续的整数，其最小值成为下界，其最大值成为上界。不加说明时下界值默认为1。