集合框架系列教材（二）- ArrayList

集合框架系列教材（一）- ArrayList - Java ArrayList 完整教程

集合框架系列教材（三）- ArrayList - ArrayList与List接口

工具版本兼容问题

本视频是解读性视频，所以希望您已经看过了本知识点的内容，并且编写了相应的代码之后，带着疑问来观看，这样收获才多。不建议一开始就观看视频

11分56秒
本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

关键字	简介	示例代码
add	增加	示例代码
contains	判断是否存在	示例代码
get	获取指定位置的对象	示例代码
indexOf	获取对象所处的位置	示例代码
remove	删除	示例代码
set	替换	示例代码
size	获取大小	示例代码
toArray	转换为数组	示例代码
addAll	把另一个容器所有对象都加进来	示例代码
clear	清空	示例代码
	练习-判断是否相同	示例代码
	答案-判断是否相同	示例代码
	练习-MyStringBuffer	示例代码
	答案-MyStringBuffer	示例代码

步骤 1 : 增加
步骤 2 : 判断是否存在
步骤 3 : 获取指定位置的对象
步骤 4 : 获取对象所处的位置
步骤 5 : 删除
步骤 6 : 替换
步骤 7 : 获取大小
步骤 8 : 转换为数组
步骤 9 : 把另一个容器所有对象都加进来
步骤 10 : 清空
步骤 11 : 练习-判断是否相同
步骤 12 : 答案-判断是否相同
步骤 13 : 练习-MyStringBuffer
步骤 14 : 答案-MyStringBuffer

步骤 1 :

增加

edit 顶折

纠问

add 有两种用法
第一种是直接add对象，把对象加在最后面

heros.add(new Hero("hero " + i));

第二种是在指定位置加对象

heros.add(3, specialHero);

TestCollection.java
重写了toString的Hero

代码行数较多，请点击查看

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 把5个对象加入到ArrayList中
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		System.out.println(heros);

		// 在指定位置增加对象
		Hero specialHero = new Hero("special hero");
		heros.add(3, specialHero);

		System.out.println(heros.toString());

	}

}

代码行数较多，请点击查看



package charactor;
 
public class Hero {
    public String name;
    public float hp;
 
    public int damage;
 
    public Hero() {
 
    }
 
    // 增加一个初始化name的构造方法
    public Hero(String name) {
 
        this.name = name;
    }
 
    // 重写toString方法
    public String toString() {
        return name;
    }
 
}

步骤 2 :

判断是否存在

edit 顶折

纠问

通过方法contains 判断一个对象是否在容器中
判断标准：是否是同一个对象，而不是name是否相同

代码行数较多，请点击查看

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);

		System.out.println(heros);
		// 判断一个对象是否在容器中
		// 判断标准： 是否是同一个对象，而不是name是否相同
		System.out.print("虽然一个新的对象名字也叫 hero 1，但是contains的返回是:");
		System.out.println(heros.contains(new Hero("hero 1")));
		System.out.print("而对specialHero的判断，contains的返回是:");
		System.out.println(heros.contains(specialHero));
	}

}

步骤 3 :

获取指定位置的对象

edit 顶折

纠问

通过get获取指定位置的对象，如果输入的下标越界，一样会报错

代码行数较多，请点击查看

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);
		
		//获取指定位置的对象
		System.out.println(heros.get(5));
		//如果超出了范围，依然会报错
		System.out.println(heros.get(6));

	}

}

步骤 4 :

获取对象所处的位置

edit 顶折

纠问

indexOf用于判断一个对象在ArrayList中所处的位置
与contains一样，判断标准是对象是否相同，而非对象的name值是否相等

代码行数较多，请点击查看

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);

		System.out.println(heros);
		System.out.println("specialHero所处的位置:"+heros.indexOf(specialHero));
		System.out.println("新的英雄，但是名字是\"hero 1\"所处的位置:"+heros.indexOf(new Hero("hero 1")));

	}
}

步骤 5 :

删除

edit 顶折

纠问

remove用于把对象从ArrayList中删除
remove可以根据下标删除ArrayList的元素

heros.remove(2);

也可以根据对象删除

heros.remove(specialHero);

代码行数较多，请点击查看

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);
		
		System.out.println(heros);
		heros.remove(2);
		System.out.println("删除下标是2的对象");
		System.out.println(heros);
		System.out.println("删除special hero");
		heros.remove(specialHero);
		System.out.println(heros);
		
	}
}

步骤 6 :

替换

edit 顶折

纠问

set用于替换指定位置的元素

代码行数较多，请点击查看

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);
		
		System.out.println(heros);
		System.out.println("把下标是5的元素，替换为\"hero 5\"");
		heros.set(5, new Hero("hero 5"));
		System.out.println(heros);
	}
}

步骤 7 :

获取大小

edit 顶折

纠问

size 用于获取ArrayList的大小

代码行数较多，请点击查看

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);
		System.out.println(heros);
		System.out.println("获取ArrayList的大小：");
		System.out.println(heros.size());
	}
}

步骤 8 :

转换为数组

edit 顶折

纠问

toArray可以把一个ArrayList对象转换为数组。
需要注意的是，如果要转换为一个Hero数组，那么需要传递一个Hero数组类型的对象给toArray()，这样toArray方法才知道，你希望转换为哪种类型的数组，否则只能转换为Object数组

代码行数较多，请点击查看

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}
		Hero specialHero = new Hero("special hero");
		heros.add(specialHero);
		System.out.println(heros);
		Hero hs[] = (Hero[])heros.toArray(new Hero[]{});
		System.out.println("数组:" +hs);

	}
}

步骤 9 :

把另一个容器所有对象都加进来

edit 顶折

纠问

addAll 把另一个容器所有对象都加进来

代码行数较多，请点击查看

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}

		System.out.println("ArrayList heros:\t" + heros);
		 
		//把另一个容器里所有的元素，都加入到该容器里来
		ArrayList anotherHeros = new ArrayList();
		anotherHeros.add(new Hero("hero a"));
		anotherHeros.add(new Hero("hero b"));
		anotherHeros.add(new Hero("hero c"));
		System.out.println("anotherHeros heros:\t" + anotherHeros);
		heros.addAll(anotherHeros);
		System.out.println("把另一个ArrayList的元素都加入到当前ArrayList:");
		System.out.println("ArrayList heros:\t" + heros);
		
	}
}

步骤 10 :

清空

edit 顶折

纠问

clear 清空一个ArrayList

代码行数较多，请点击查看

package collection;

import java.util.ArrayList;

import charactor.Hero;

public class TestCollection {
	public static void main(String[] args) {
		ArrayList heros = new ArrayList();

		// 初始化5个对象
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i));
		}

		System.out.println("ArrayList heros:\t" + heros);
		System.out.println("使用clear清空");
		heros.clear();
		System.out.println("ArrayList heros:\t" + heros);
		 
	}
}

步骤 11 :

练习-判断是否相同

edit 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

如果就是要判断集合里是否存在一个 name等于 "hero 1"的对象，应该怎么做？

步骤 12 :

答案-判断是否相同

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费3个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

1分31秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

代码行数较多，请点击查看

package collection;
 
import java.util.ArrayList;
 
import charactor.Hero;
 
public class TestCollection {
    public static void main(String[] args) {
        ArrayList heros = new ArrayList();
 
        // 初始化5个对象
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero " + i));
        }
        Hero specialHero = new Hero("special hero");
        heros.add(specialHero);
        String name = "hero 1";
        for (int i = 0; i < heros.size(); i++) {
			Hero h = (Hero) heros.get(i);
			if(name.equals(h.name ) ){
				System.out.printf("找到了name是%s的对象",name);
				break;
			}
		}
        
    }
 
}

步骤 13 :

练习-MyStringBuffer

edit 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

做一个一样的MyStringBuffer练习，但是不使用字符数组，而是使用ArrayList来实现

步骤 14 :

答案-MyStringBuffer

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费4个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

12分24秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

package character; import java.util.ArrayList; public class MyStringBuffer implements IStringBuffer { // int capacity = 16;//不需要自己维护capacity,capacity在ArrayList中由ArrayList维护 // int length = 0; //不需要自己维护length,length ArrayList的size ArrayList value; public MyStringBuffer() { value = new ArrayList(); } // 有参构造方法 public MyStringBuffer(String str) { this(); if (null == str) return; char[] cs = str.toCharArray(); for (int i = 0; i < cs.length; i++) { char c = cs[i]; value.add(c); } } @Override public void append(String str) { insert(value.size(), str); } @Override public void append(char c) { append(String.valueOf(c)); } @Override public void insert(int pos, char b) { insert(pos, String.valueOf(b)); } @Override public void delete(int start) { delete(start, value.size()); } @Override public void delete(int start, int end) { // 边界条件判断 if (start < 0) return; if (start > value.size()) return; if (end < 0) return; if (end > value.size()) return; if (start >= end) return; for (int i = 0; i < end - start; i++) { value.remove(start); } } @Override public void reverse() { for (int i = 0; i < value.size() / 2; i++) { int length = value.size(); char temp = (char) value.get(i); value.set(i, value.get(length - i - 1)); value.set(length - i - 1, temp); } } @Override public int length() { // TODO Auto-generated method stub return value.size(); } @Override public void insert(int pos, String b) { // 边界条件判断 if (pos < 0) return; if (pos > value.size()) return; if (null == b) return; // 无需手动扩容 char[] cs = b.toCharArray(); for (int i = 0; i < cs.length; i++) { char c = cs[i]; value.add(pos + i, c); } } public String toString() { char[] charValue = new char[value.size()]; for (int i = 0; i < value.size(); i++) { charValue[i] = (char) value.get(i); } return new String(charValue); } public static void main(String[] args) { MyStringBuffer sb = new MyStringBuffer("there light"); System.out.println(sb); sb.insert(0, "let "); System.out.println(sb); sb.insert(10, "be "); System.out.println(sb); sb.insert(0, "God Say:"); System.out.println(sb); sb.append("!"); System.out.println(sb); sb.append('?'); System.out.println(sb); sb.reverse(); System.out.println(sb); sb.reverse(); System.out.println(sb); sb.delete(0, 4); System.out.println(sb); sb.delete(4); System.out.println(sb); } }

代码行数较多，请点击查看

package character;

import java.util.ArrayList;

public class MyStringBuffer implements IStringBuffer {

	// int capacity = 16;//不需要自己维护capacity,capacity在ArrayList中由ArrayList维护
	// int length = 0; //不需要自己维护length,length ArrayList的size
	ArrayList value;

	public MyStringBuffer() {
		value = new ArrayList();
	}

	// 有参构造方法
	public MyStringBuffer(String str) {
		this();
		if (null == str)
			return;
		char[] cs = str.toCharArray();
		for (int i = 0; i < cs.length; i++) {
			char c = cs[i];
			value.add(c);
		}

	}

	@Override
	public void append(String str) {

		insert(value.size(), str);
	}

	@Override
	public void append(char c) {
		append(String.valueOf(c));

	}

	@Override
	public void insert(int pos, char b) {
		insert(pos, String.valueOf(b));
	}

	@Override
	public void delete(int start) {

		delete(start, value.size());
	}

	@Override
	public void delete(int start, int end) {
		// 边界条件判断
		if (start < 0)
			return;

		if (start > value.size())
			return;

		if (end < 0)
			return;

		if (end > value.size())
			return;

		if (start >= end)
			return;

		for (int i = 0; i < end - start; i++) {
			value.remove(start);
		}

	}

	@Override
	public void reverse() {
		for (int i = 0; i < value.size() / 2; i++) {
			int length = value.size();
			char temp = (char) value.get(i);

			value.set(i, value.get(length - i - 1));

			value.set(length - i - 1, temp);
		}
	}

	@Override
	public int length() {
		// TODO Auto-generated method stub
		return value.size();
	}

	@Override
	public void insert(int pos, String b) {

		// 边界条件判断
		if (pos < 0)
			return;

		if (pos > value.size())
			return;

		if (null == b)
			return;

		// 无需手动扩容

		char[] cs = b.toCharArray();
		for (int i = 0; i < cs.length; i++) {
			char c = cs[i];
			value.add(pos + i, c);
		}
	}

	public String toString() {

		char[] charValue = new char[value.size()];
		for (int i = 0; i < value.size(); i++) {
			charValue[i] = (char) value.get(i);
		}
		return new String(charValue);

	}

	public static void main(String[] args) {
		MyStringBuffer sb = new MyStringBuffer("there light");
		System.out.println(sb);
		sb.insert(0, "let ");
		System.out.println(sb);

		sb.insert(10, "be ");
		System.out.println(sb);
		sb.insert(0, "God Say:");
		System.out.println(sb);
		sb.append("!");
		System.out.println(sb);
		sb.append('?');
		System.out.println(sb);
		
		sb.reverse();
		System.out.println(sb);

		sb.reverse();
		System.out.println(sb);

		sb.delete(0, 4);
		System.out.println(sb);
		sb.delete(4);
		System.out.println(sb);

	}

}

集合框架系列教材（一）- ArrayList - Java ArrayList 完整教程

集合框架系列教材（三）- ArrayList - ArrayList与List接口

HOW2J公众号，关注后实时获知最新的教程和优惠活动，谢谢。

问答区域

2024-07-07 使用链表的方法改写StringBuffer

虚心求学

关于 JAVA 中级-集合框架-常用方法的提问

测试内容：将 MyStringBufferList(底层维护ArrayList<Character>)、MyStringBufferPro(底层维护char[])、StringBufferPro(底层维护char[])、String之间的性能对比。测试结果：在追加的性能方面： MyStringBufferPro>StringBufferPro>MyStringBufferList>String; 详细数据见截图。结论：这说明了，使用链表来改写性能方面来说是不如数组的，但仍比String直接进行拼接的效率高。

package j2se;

import java.util.ArrayList;
import java.util.Arrays;

public final class MyStringBufferList implements IStringBuffer {
	private ArrayList<Character> data;
	public MyStringBufferList()
	{
		data = new ArrayList<Character>();
	}	
	public MyStringBufferList(String str)
	{
		data = new ArrayList<Character>();
		append(str);
	}
	public MyStringBufferList(char c)
	{
		data = new ArrayList<Character>();
		append(c);
	}
	@Override
	public void append(String str) {
		// TODO Auto-generated method stub
		char[]cs = new char[str.length()];
		str.getChars(0, str.length(), cs, 0);
		for (char c : cs) {
			append(c);
		}
	}

	@Override
	public void append(char c) {
		data.add(c);
	}
	public void append(char[] cs) {
		for (char c : cs) {
			append(c);
		}
	}
	@Override
	public void append(String... strs) {
		// TODO Auto-generated method stub
		for (String str : strs) {
			append(str);
		}
	}

	@Override
	public void insert(int pos, char c) throws IndexIsNagetiveException, IndexIsOutofRangeException {
		checkIndexValid(pos);
		data.add(pos,c);
	}

	@Override
	public void insert(int pos, String str) throws IndexIsNagetiveException, IndexIsOutofRangeException {
		checkIndexValid(pos);
		char[]cs = new char[str.length()];
		str.getChars(0, str.length(), cs, 0);
		for (char c : cs) {
			insert(pos++,c);
		}
	}

	@Override
	public void delete(int start) throws IndexIsNagetiveException, IndexIsOutofRangeException {
		checkIndexValid(start);
		for (int i = data.size()-1; i >=start; i--) {
			data.remove(i);
		}
	}
	@Override
	public void delete(int start, int end) throws IndexIsNagetiveException, IndexIsOutofRangeException {
		checkIndexValid(start,end);
		for (int i = end; i >=start; i--) {
			data.remove(i);
		}
	}
	private boolean checkIndexValid(int id) throws IndexIsNagetiveException,IndexIsOutofRangeException
	{
		if(id<0||id>data.size()-1)
		{
			if(id<0)throw new IndexIsNagetiveException("Exception：索引不得小于0");
			if(id>data.size()-1)throw new IndexIsOutofRangeException("Exception：索引越界，大于数组的 边界或大于有效位置");
			return false;
		}
		return false;
	}
	private boolean checkIndexValid(int start,int end) throws IndexIsNagetiveException, IndexIsOutofRangeException
	{
		boolean res = true;
		res = res&&checkIndexValid(start);
		res = res&&checkIndexValid(end);
		if(start>=end)
		{
			res = false;
			throw new IndexIsNagetiveException("Exception：待删除的起始位置需在结束位置之前，不得大于等于结束位置");
		}
		return res;
	}
	public void clear()
	{
		data.clear();
	}
	@Override
	public void reverse() {
		// 0 1 2     0 1 2 3
		for (int i = 0; i < data.size()/2; i++) {
			char temp = data.get(data.size()-i-1);
			data.set(data.size()-i-1, data.get(i));
			data.set(i,temp);
		}
	}

	@Override
	public int length() {
		// TODO Auto-generated method stub
		return this.data.size();
	}
	@Override
	public String toString()
	{
		String str = "";
		for (char c : data) {
			str+=c;
		}
		return str;
	}

}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2022-05-28 答案

大D

关于 JAVA 中级-集合框架-常用方法的提问

判断是否相同重写StringBuffer

String name ="hero1";
        for(int j=0;j<hero.size();j++){
            Hero h1= (Hero) hero.get(j);
            if(name.equals(h1.name)){
                System.out.println("zhaodaole"+name);
                break;
            }
        }








import java.util.ArrayList;

public class StingBUffer2 implements IStringBuffer2 {

    ArrayList list =new ArrayList();
    @Override
    public void append(String str) {
        if(str==null){
            return;
        }
        list.add(str);
    }

    @Override
    public void append(char c) {

        list.add(c);
    }

    @Override
    public void insert(int pos, char b) {
       if(pos<0||pos>list.size()){
           return;
       }else {
           list.add(pos, b);
       }
    }

    @Override
    public void insert(int pos, String b) {
        if(pos<0||pos>list.size()){
            return;
        }else{
            list.add(pos,b);
        }

    }

    @Override
    public void delete(int start) {
        list.remove(start);
    }

    @Override
    public void delete(int start, int end) {
        if(start<0||start>list.size()){
            return;
        }else if(end>list.size()||end<0){
            return;
        }else{
            list.remove(start);
        }
    }

    @Override
    public void reverse() {
      for(int i=0;i<list.size()/2;i++){
          char  c= (char) list.get(i);
          list.set(i,list.get(list.size()-1-i));
          list.set(list.size()-i-1,c);
      }
    }

    @Override
    public int length() {
        return list.size();
    }


    public static void main(String[] args) {
        StingBUffer2 sb =new StingBUffer2();
        sb.append('1');
        sb.append('2');
        sb.append('3');
        sb.append('4');
        sb.append('5');
        sb.reverse();
        System.out.println(sb.list.toString());
    }

}


public interface IStringBuffer2 {


        public void append(String str);//追加字符串
        public void append(char c);//追加字符
        public void insert(int pos, char b);//指定位置插入字符
        public void insert(int pos, String b);//指定位置插入字符串
        public void delete(int start);//从开始位置删除剩下的
        public void delete(int start, int end);//从开始位置删除结束位置-1
        public void reverse();//反转
        public int length();//返回长度
    }

1 个答案

木宇
答案时间：2024-06-01

练习1

代码超过 5行，点击查看

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2022-05-28 是否相同

大D	关于 JAVA 中级-集合框架-常用方法的提问问题截图代码异常判断是否相同 String name ="hero1"; for(int j=0;j<hero.size();j++){ Hero h1= (Hero) hero.get(j); if(name.equals(h1.name)){ System.out.println("zhaodaole"+name); break; } }

3 个答案

wr123
答案时间：2023-11-23

package collection; import java.util.ArrayList; import charactor.Hero; public class TestCollection { public static void main(String[] args) { ArrayList heros = new ArrayList(); // 初始化5个对象 for (int i = 0; i < 5; i++) { heros.add(new Hero("hero " + i)); } System.out.println("ArrayList heros:\t" + heros); boolean judge=false; for(int i=0;i<heros.size();i++){ if(heros.get(i).toString().equals("hero 1")){ judge=true; break; } } System.out.println("是否存在name为”hero 1“的对象:"+judge); } }

CharlieLong
答案时间：2023-09-19

答案：如果就是要判断集合里是否存在一个 name等于 "hero 1"的对象，应该怎么做？

代码超过 5行，点击查看

CharlieLong
答案时间：2023-09-19

判断是否相同

代码超过 5行，点击查看

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2021-11-29 MyStringBuffer重写

sysucjf

关于 JAVA 中级-集合框架-常用方法的提问

已通过测试

package charac;

import java.util.ArrayList;
import java.util.Arrays;

public class MyStringBuffer2 implements IStringBuffer{
	  
    int capacity = 16;
    int length = 0;
//    char[] value;
    ArrayList<Character> value = new ArrayList();//加一个泛型
    public MyStringBuffer2(){
//        value = new char[capacity];
    	//因为ArrayList是可自由扩展的“数组”，所以不需要重新构建数组
    }
      
    //有参构造方法
    public MyStringBuffer2(String str) {
        if(null==str)
            return;
        
        capacity=capacity+str.length();
//        value = new char[capacity];
//        System.arraycopy(str.toCharArray(), 0, value, 0, str.length());
        for (int i = 0; i < str.length(); i++) {
			value.add(str.charAt(i));
		}
          
        length = str.length();
          
    }
      
    @Override
    public void append(String str) throws Exception {
        insert(length,str);
    }
  
    @Override
    public void append(char c) throws Exception {
        append(String.valueOf(c));
          
    }
  
    @Override
    public void insert(int pos, char b) throws Exception {
        insert(pos,String.valueOf(b));
    }
  
    @Override
    public void delete(int start,int end) throws Exception {//删除是左开右闭
    	//边界条件判断
        if(start<0)//IndexIsNagetiveException
        	throw new IndexIsNegativeException("删除起始下标小于0！");
         
        if(start>length)//IndexIsOutofRangeException
        	throw new IndexIsOutofRangeException("删除起始下标越界！");
         
        if(end<0)//IndexIsNagetiveException
        	throw new IndexIsNegativeException("删除结束下标小于0！");
         
        if(end>length)//IndexIsOutofRangeException
        	throw new IndexIsOutofRangeException("删除结束下标越界！");
         
        if(start>=end)//IndexIsOutofRangeException
        	throw new IndexIsOutofRangeException("删除起始下标大于结束下标！");
         
//        System.arraycopy(value, end, value, start, length- end);
        /**以下是错误的移除方式*/
//        for(int i = start;i < end;i++)
//        	value.remove(i);
        while(start < end) {
        	value.remove(start);
        	end--;
        }
        	
        
        length = value.size();
          
    }
  
    @Override
    public void delete(int start) throws Exception {
    	delete(start,length);//不给出end说明是直接删除start之后全部数组，实际上直接修改length即可
          
    }
  
    @Override
    public void reverse() {
        for (int i = 0; i < length/2; i++) {
            char temp = value.get(i);
//            value[i] = value[length-i-1];
            value.set(i, value.get(length-i-1));
//            value[length-i-1] = temp;
            value.set(length-i-1, temp);
        }
    }
  
    @Override
    public int length() {
        // TODO Auto-generated method stub
        return length;
    }
  
    @Override
    public void insert(int pos, String b) throws Exception {
  
        //边界条件判断
        if(pos<0)//IndexIsNagetiveException
        	throw new IndexIsNegativeException("插入下标小于0！");
          
        if(pos>length)// IndexIsOutofRangeException
            throw new IndexIsOutofRangeException("插入下标越界！");
          
        if(null==b)//NullPointerException
            throw new NullPointerException("插入内容为空");
          
        //扩容
        if(capacity<length+b.length()){
            if(capacity*2+2>length+b.length())
            	capacity=capacity*2+2;
            else
            	capacity=b.length();
//            char[] newValue = new char[capacity];            
//            System.arraycopy(value, 0, newValue, 0, length);
//            value = newValue;
        }
        
          
        char[] cs = b.toCharArray();//插入字符串转为字符数组
          
        //先把已经存在的数据往后移
          
//        System.arraycopy(value, pos, value,pos+ cs.length, length-pos);
        //把要插入的数据插入到指定位置
//        System.arraycopy(cs, 0, value, pos, cs.length);
        int restLength = cs.length;
        int addPos = pos;
        int csIndex = 0;
        while(restLength>0) {
        	value.add(addPos, cs[csIndex]);
        	addPos++;
        	csIndex++;
        	restLength--;
        }
          
        length = length+cs.length;
          
    }
      
    public String toString(){
          
//        char[] realValue = new char[length];
    	Character[] realValue =value.toArray(new Character[value.size()]);
  
//        System.arraycopy(value, 0, realValue, 0, length);
    	char[] charValue = new char[realValue.length];
    	for (int i = 0; i < charValue.length; i++) {
			charValue[i]=realValue[i];//自动拆箱
		}
          
//        return Arrays.toString(realValue);//这样没办法输出字符串，而是输出以字符串形式展示的数组
    	return new String(charValue);
          
    }
    /*异常*/
    class IndexIsNegativeException extends Exception{
    	public IndexIsNegativeException() {}
    	public IndexIsNegativeException(String msg) {
    		super(msg);
    	}
    }
    class IndexIsOutofRangeException extends Exception{
    	public IndexIsOutofRangeException() {}
    	public IndexIsOutofRangeException(String msg) {
    		super(msg);
    	}
    }
      
    public static void main(String[] args) {
    	MyStringBuffer2 sb = new MyStringBuffer2("there light");
    	try {
    		
            System.out.println(sb);
            sb.insert(0, "let ");
            System.out.println(sb);
      
            sb.insert(10, "be ");
            System.out.println(sb);
            sb.insert(0, "God Say:");
            System.out.println(sb);
            sb.append("!");
            System.out.println(sb);
            sb.append('?');
            System.out.println(sb);
            sb.reverse();
            System.out.println(sb);
            sb.reverse();
            System.out.println(sb);
             
            sb.delete(0,4);
            System.out.println(sb);
            sb.delete(4);
            System.out.println(sb);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
        
        
        /*测试异常*/
    	try {
			sb.insert(0,null);
			sb.insert(-1,"test");
			sb.insert(5,"test");
			
			sb.delete(-1, 1);
			sb.delete(3,5);
			sb.delete(1,0);
			
		} catch (Exception e) {
			// TODO: handle exception
			if(e instanceof NullPointerException)
				System.out.println("出现空指针异常");
			if(e instanceof IndexIsNegativeException | e instanceof IndexIsOutofRangeException )
				System.out.println("出现下标异常");
			
			e.printStackTrace();
		}
    	
        
          
    }
  
}

2 个答案

304524
答案时间：2022-04-24

/*如果就是要判断集合里是否存在一个 name等于 "hero 1"的对象，应该怎么做？*/

代码超过 5行，点击查看

package Collection.cast.demo1;

import sn.cast.demo13.A;
import sn.cast.demo3.Arr;

import java.util.ArrayList;

public class TestCollection {
    public static void main(String[] args) {
        ArrayList heros=new ArrayList();
        for (int i = 0; i<5; i++) {
            heros.add("hero"+(i+1));
        }
        /*System.out.println(heros);
        Hero sp=new Hero("spHero");
        heros.add(3,sp);//将sp插入在第三个位置
        System.out.println(heros);
        // 判断一个对象是否在容器中,通过方法contains判断一个对象是否在容器中
        // 判断标准： 是否是同一个对象，而不是name是否相同
        System.out.println("hero2是否在该容器中："+heros.contains("hero2"));
        System.out.println("hero 2是否在该容器中："+heros.contains("hero 2"));
        //通过get获取指定位置的对象，如果输入的下标越界，一样会报错
        System.out.println("第三个对象是："+heros.get(2));
        //indexOf用于判断一个对象在ArrayList中所处的位置
        //与contains一样，判断标准是对象是否相同，而非对象的name值是否相等
        System.out.println("hero1的位置在："+heros.indexOf("hero1"));
        //remove用于把对象从ArrayList中删除
        //remove可以根据下标删除ArrayList的元素
        System.out.println("删除前："+heros);
        System.out.println("删除hero1："+heros.remove(0));
        System.out.println("删除后："+heros);
        //set用于替换指定位置的元素
        heros.set(0,"hero10");
        System.out.println("将hero2换成hero10："+heros);
        //size 用于获取ArrayList的大小
        System.out.println("该容器的大小为："+heros.size());
        //toArray可以把一个ArrayList对象转换为数组。
        //需要注意的是，如果要转换为一个Hero数组，那么需要传递一个Hero数组类型的对象给toArray()，这样toArray方法才知道，你希望转换为哪种类型的数组，否则只能转换为Object数组
        *//*//*/
        /*heros.toArray();
        System.out.print("转化为数组为：");
        for (Object hero : heros) {
            System.out.print(hero+" ");
        }*//*
        //addAll 把另一个容器所有对象都加进来
        ArrayList hero11=new ArrayList();
        hero11.add("hero a");
        hero11.add("hero b");
        hero11.add("hero c");
        System.out.println("heros:"+heros);
        System.out.println("hero11:"+hero11);
        System.out.println("将hero11的元素都添加到heros中为：");
        heros.addAll(hero11);
        System.out.println("添加后："+heros);*/
        System.out.println(heros);
        Object[] Array=heros.toArray();
        for (Object o : Array) {
            System.out.println(o);
        }
        int count=0;
        for(int i = 0; i< Array.length; i++)
        {
            if(Array[i]=="hero2"){
                System.out.println("找到了name是hero2的对象");
                count++;
                break;
            }
        }
        if(count==0){
            System.out.println("没有找到name是hero2的的对象");
        }
    }
}

hoolich
答案时间：2022-04-06

/*如果就是要判断集合里是否存在一个 name等于 "hero 1"的对象，应该怎么做？*/ package collection; import java.util.ArrayList; import charactor.Hero; public class TestCollection { public static void main(String[] args) { ArrayList heros = new ArrayList(); // 初始化5个对象 for (int i = 0; i < 5; i++) { heros.add(new Hero("hero " + i)); } Hero hs[] = (Hero[])heros.toArray(new Hero[]{}); for (int i = 0; i < hs.length; i++) { if(hs[i].name.equals("hero 1")){ System.out.println("找到了name为"+hs[i].name+"的对象"); break; } } } }

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2021-11-20 全家桶

黄铜小马

关于 JAVA 中级-集合框架-常用方法的提问

全家桶

import java.util.ArrayList;
import java.util.Arrays;

public class TestCollection {
    public static void main(String[] args) {
        try{
            Hero hero[] = new Hero[10];
            hero[0] = new Hero("盖伦");
            hero[20] = new Hero("提莫");
        }
        catch (Exception e){
            e.printStackTrace();
        }

//        ---------------------------
        ArrayList<Hero> heroes = new ArrayList<Hero>();
        heroes.add(new Hero("盖伦"));
        heroes.add(new Hero("提莫"));
        System.out.println(heroes);
        for (int i = 0; i < 5; i++) {
            heroes.add(new Hero("假人"+i));
        }
        heroes.add(3,new Hero("插队的"));
        System.out.println(heroes);
        heroes.removeIf(h -> h.getName().equals("插队的"));
        System.out.println(heroes);
        Hero p = new Hero("破败之王");
        heroes.add(p);
        System.out.println(heroes.indexOf(p));
        System.out.println(heroes);
        if (heroes.contains(p)){
            heroes.set(heroes.size() - 1,new Hero("铁甲小宝"));
        }
        System.out.println(heroes);
        System.out.println("________________________________________________");
        ArrayList<Hero> heroes1 = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            heroes1.add(new Hero("真的是假人"+i));
        }
        heroes.addAll(heroes1);
        System.out.println(heroes);
        Object[] array = heroes1.toArray();
        System.out.println(heroes1);
        System.out.println(array[0]);
        heroes.clear();
        System.out.println(heroes);

    }
}

1 个答案

hoolich
答案时间：2022-04-07

/*对MyStringBuffer的插入和删除方法中的边界条件判断，用抛出异常来解决例: insert(int pos, String b) , 当pos 是负数的时候，抛出自定义异常需要实现自定义两种异常 IndexIsNagetiveException 下标为负异常 IndexIsOutofRangeException 下标超出范围异常以下是需要调用这些异常的场景： pos<0 抛出 IndexIsNagetiveException pos>length 抛出 IndexIsOutofRangeException null==b 抛出 NullPointerException start<0 抛出 IndexIsNagetiveException start>length 抛出 IndexIsOutofRangeException end<0 抛出 IndexIsNagetiveException end>length 抛出 IndexIsOutofRangeException start>=end 抛出 IndexIsOutofRangeException 注意：接口IStringBuffer中声明的方法需要抛出异常*/ package character; import exception.IndexIsNagetiveException; import exception.IndexIsOutofRangeException; import java.util.ArrayList; public class MyStringBuffer implements IStringBuffer{ // int capacity = 16; // int length = 0; // char[] value; ArrayList value; public MyStringBuffer(){ value = new ArrayList(); } public MyStringBuffer(String str){ this(); if(null!=str) // value =str.toCharArray(); return; // length = value.length; // if(capacity<value.length) // capacity = value.length*2; char[] cs = str.toCharArray(); for (int i = 0; i < cs.length; i++) { char c = cs[i]; value.add(c); } } @Override public void append(char c) throws IndexIsNagetiveException, IndexIsOutofRangeException { value.add(c); } @Override public int length() { return value.size(); } @Override public void append(String str) throws IndexIsNagetiveException, IndexIsOutofRangeException { insert(value.size(),str); } @Override public void delete(int start) throws IndexIsNagetiveException, IndexIsOutofRangeException { delete(start, value.size()); } @Override public void delete(int start, int end) throws IndexIsNagetiveException, IndexIsOutofRangeException { //边界条件判断 if(start<0) throw new IndexIsNagetiveException(); if(start>value.size()) throw new IndexIsOutofRangeException(); if(end<0) throw new IndexIsNagetiveException(); if(end>value.size()) throw new IndexIsOutofRangeException(); if(start>=end) throw new IndexIsOutofRangeException(); for(int i=start;i<end;i++) { value.remove(i); } // System.arraycopy(value, end, value, start, value.size()- end); // value.size()-=end-start; } @Override public void insert(int pos, char b)throws IndexIsNagetiveException,IndexIsOutofRangeException { insert(pos,String.valueOf(b)); } @Override public void insert(int pos, String b)throws IndexIsNagetiveException,IndexIsOutofRangeException { //边界条件判断 if(pos<0) throw new IndexIsNagetiveException(); if(pos>value.size()) throw new IndexIsOutofRangeException(); if(null==b) throw new NullPointerException(); //扩容 // while(value.size()+b.length()>capacity){ // capacity = (int) ((length+b.length())*1.5f); // System.arraycopy(value, 0, newValue, 0, length); value.add(pos,b); // value = newValue; // } // char[] cs = b.toCharArray(); //先把已经存在的数据往后移 // System.arraycopy(value, pos, value,pos+ cs.length, length-pos); //把要插入的数据插入到指定位置 // System.arraycopy(cs, 0, value, pos, cs.length); // length = length+cs.length; } @Override public void reverse() { for(int i=0;i<value.size()/2;i++){ char temp=(char)value.get(i); value.set(i,value.get(value.size()-i-1)); value.set(value.size()-i-1,temp); } } public String getStr1() { return String.valueOf(value); } public void setStr1(String str1) { char[] cs = str1.toCharArray(); value.clear(); for (int i = 0; i < str1.length(); i++) { value.set(i, cs[i]); } } public static void main(String[] args) { } }

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

提问太多，页面渲染太慢，为了加快渲染速度，本页最多只显示几条提问。还有 65 条以前的提问，请点击查看

提问之前请登陆

提问已经提交成功，正在审核。请于我的提问处查看提问记录，谢谢

关于 JAVA 中级-集合框架-常用方法的提问

尽量提供截图、代码和异常信息，有助于分析和解决问题。也可进本站QQ群交流: 578362961

提问尽量提供完整的代码，环境描述，越是有利于问题的重现，您的问题越能更快得到解答。
对教程中代码有疑问，请提供是哪个步骤，哪一行有疑问，这样便于快速定位问题，提高问题得到解答的速度
在已经存在的几千个提问里，有相当大的比例，是因为使用了和站长不同版本的开发环境导致的,比如 jdk, eclpise, idea, mysql,tomcat 等等软件的版本不一致。
请使用和站长一样的版本，可以节约自己大量的学习时间。站长把教学中用的软件版本整理了，都统一放在了这里，方便大家下载： https://how2j.cn/k/helloworld/helloworld-version/1718.html

上传截图