Java的ArrayList应用(查增改删)

已于 2022-09-04 23:29:08 修改
阅读量3.7k 收藏 21
点赞数 1
分类专栏： L02-Java基础 文章标签： java spring boot
于 2022-08-31 22:11:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangbeizhen18/article/details/126632981
版权

记录：294

场景：Java的ArrayList理解与应用。把对ArrayList操作，从查、增、改、删的角度去理解和应用ArrayList的API。

版本：

JDK 1.8
Spring Boot 2.6.3

名词：

API，应用程序接口(Application Programming Interface)。API是一些预定的函数，提供给应用程序访问。调用方无需关注API内部源码和内部工作机制等细节，只需根据API提供方发布的调用方式调用API就行。

一、基础

1.基础知识

1.1 ArrayList基础知识

(1)ArrayList底层是一个可变数组，使用transient关键字修饰的Object[]数组。

(2)ArrayList实现List、Collection等接口，实现了List的全部操作。

(3)ArrayList支持动态扩容，在做add操作时，容量不足时，会自动扩容。扩容时会使用Arrays.copyOf函数进行拷贝操作。扩容规则：(oldCapacity >> 1)，即扩展原有容量一半。

(4)ArrayList是线程不安全集合。在多线程操作时，需使用者自行加锁处理。

(5)ArrayList允许写入null。

1.2 ArrayList继承类和实现的接口

ArrayList在jdk中全路径：java.util.ArrayList。

ArrayList继承的抽象类：

java.util.AbstractList
java.util.AbstractCollection

ArrayList实现的接口：

java.util.List
java.util.RandomAccess
java.lang.Cloneable
java.io.Serializable
java.util.Collection
java.lang.Iterable

1.3 ArrayList内部类

ArrayList内部类，包括如下：

java.util.ArrayList.Itr
java.util.ArrayList.ListItr
java.util.ArrayList.SubList
java.util.ArrayList.ArrayListSpliterator

2.应用场景

ArrayList，只要使用集合的场景都可以使用。

二、应用

1.创建

创建，就是创建ArrayList操作，就能得到一个实际Java对象。

1.1操作场景

操作场景，函数功能说明。

(1)使用new创建长度为0的List对象。

(2)使用new创建长度为100的List对象。

(3)使用实现Collection<?extendsE>接口的类创建对象。

1.2操作实例

操作实例，函数应用实例。

/**
 * 1.使用new关键字创建ArrayList对象实例
 */
public static void f_new() {

  // 1.使用new创建长度为0的List对象
  List<GirlVo> list01 = new ArrayList<>();
  // 2.使用new创建长度为100的List对象
  List<GirlVo> list02 = new ArrayList<>(100);
  // 3.使用实现Collection<? extends E>接口的类创建对象
  HashSet<String> hs = new HashSet<>();
  hs.add("杭州");
  hs.add("苏州");
  hs.add("厦门");
  List<String> list03 = new ArrayList<>(hs);
  list03.forEach(str -> {
      System.out.println("城市名称: " + str);
  });
}

2.查

查，就是查询操作。

2.1操作场景

操作场景，函数功能说明。

(1)使用forEach遍历ArrayList集合。

(2)使用for循环,搭配get(intindex),遍历ArrayList集合。

(3)使用增强for循环,遍历ArrayList集合。

(4)使用ListIterator<E>listIterator(),遍历ArrayList集合。

(5)使用ListIterator<E>listIterator(intindex),按照指定位置开始,遍历ArrayList集合。

(6)使用iterator(),遍历ArrayList集合。

(7)使用spliterator(),遍历ArrayList集合。

(8)使用stream(),把ArrayList转换为Stream,遍历ArrayList集合。

(9)使用sort(Comparator<?superE>c)排序,遍历ArrayList集合。

(10)使用get(intindex),获取ArrayList指定位置的元素。

(11)使用size(),获取ArrayList的size。

(12)使用isEmpty(),判断ArrayList是否为空。

(13)使用contains(),判断ArrayList是否包含指定对象。

(14)使用indexOf(),获取ArrayList索引位置。

(15)使用lastIndexOf()获取ArrayList最后一个索引位置。

(16)使用clone(),复制ArrayList的元素。

2.2操作实例

操作实例，函数应用实例。

/**
 * 1.1 使用forEach遍历ArrayList集合
 */
public static void f1_1() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.遍历数据
  list.forEach(girl -> {
      System.out.println("girl信息: " + girl.toString());
  });
}

/**
 * 1.2 使用for循环,搭配get(int index),遍历ArrayList集合
 */
public static void f1_2() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.遍历数据
  for (int i = 0; i < list.size(); i++) {
      System.out.println("girl信息: " + list.get(i));
  }
}

/**
 * 1.3 使用增强for循环,遍历ArrayList集合
 */
public static void f1_3() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.遍历数据
  for (GirlVo girlVo : list) {
      System.out.println("girl信息: " + girlVo);
  }
}

/**
 * 1.4 使用ListIterator<E> listIterator(),遍历ArrayList集合
 */
public static void f1_4() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.使用listIterator
  ListIterator<GirlVo> iterator = list.listIterator();
  // 3.使用Iterator遍历
  while (iterator.hasNext()) {
      System.out.println("遍历Iterator: " + iterator.next());
  }
}

/**
 * 1.5 使用ListIterator<E> listIterator(int index),按照指定位置开始,
 * 遍历ArrayList集合
 */
public static void f1_5() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.使用listIterator
  ListIterator<GirlVo> iterator = list.listIterator(2);
  // 3.使用Iterator遍历
  while (iterator.hasNext()) {
      System.out.println("遍历Iterator: " + iterator.next());
  }
}

/**
 * 1.6 使用iterator(),遍历ArrayList集合
 */
public static void f1_6() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.使用iterator
  Iterator<GirlVo> iterator = list.iterator();
  // 3.使用iterator遍历
  while (iterator.hasNext()) {
      System.out.println("遍历Iterator: " + iterator.next());
  }
}

/**
 * 1.7 使用spliterator(),遍历ArrayList集合
 * JDK 1.8
 */
public static void f1_7() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.使用Spliterator
  Spliterator<GirlVo> iterator = list.spliterator();
  // 3.使用Spliterator遍历
  iterator.forEachRemaining(girlVo -> {
      System.out.println("使用分流器遍历: " + girlVo);
  });
}

/**
 * 1.8 使用stream(),把ArrayList转换为Stream,遍历ArrayList集合
 */
public static void f1_8() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.ArrayList转换为
  Stream<GirlVo>  stream = list.stream();
  // 3.遍历数据
  stream.forEach(girlVo -> {
      System.out.println("girl信息: " + girlVo);
  });
}

/**
 * 1.9 使用sort(Comparator<? super E> c)排序,遍历ArrayList集合
 * 需自定义Comparator比较器,本例按照GirlVo的年龄排序.
 */
public static void f1_9() {
  // 1.获取数据
  List<GirlVo> list = getList();
  System.out.println("操作前遍历信息:");
  list.forEach(girlVo -> {
      System.out.println("girl信息: " + girlVo);
  });
  // 2.比较器确定排序规则
  list.sort((c1, c2) -> {
      return (int) (c1.getAge() - c2.getAge());
  });
  System.out.println("操作后遍历信息:");
  list.forEach(girlVo -> {
      System.out.println("girl信息: " + girlVo);
  });
}

/**
 * 1.10 使用get(int index),获取ArrayList指定位置的元素
 */
public static void f1_10() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.使用get获取元素
  GirlVo girlVo = list.get(2);
  System.out.println("girl信息: " + girlVo);
}

/**
 * 1.11 使用size(),获取ArrayList的size
 */
public static void f1_11() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.使用size
  int size = list.size();
  System.out.println("List的size: " + size);
}

/**
 * 1.12 使用isEmpty(),判断ArrayList是否为空
 */
public static void f1_12() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.使用isEmpty
  boolean bl = list.isEmpty();
  System.out.println("List是否为空: " + bl);
}

/**
 * 1.13使用contains(),判断ArrayList是否包含指定对象
 */
public static void f1_13() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.使用contains
  GirlVo girl01 = GirlVo.builder().girlId("1001").girlName("张一").age(27).height(169).cupSize("F").build();
  boolean bl = list.contains(girl01);
  System.out.println("List是包含指定对象: " + bl);
}

/**
 * 1.14 使用indexOf(),获取ArrayList索引位置
 */
public static void f1_14() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.使用indexOf
  GirlVo girl01 = GirlVo.builder().girlId("1001").girlName("张一").age(27).height(169).cupSize("F").build();
  int index = list.indexOf(girl01);
  System.out.println("girl01的索引位置: " + index);
}

/**
 * 1.15 使用lastIndexOf()获取ArrayList最后一个索引位置
 */
public static void f1_15() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.使用lastIndexOf
  GirlVo girl01 = GirlVo.builder().girlId("1001").girlName("张一").age(27).height(169).cupSize("F").build();
  list.add(girl01);
  int index = list.lastIndexOf(girl01);
  System.out.println("girl01的最后索引位置: " + index);
}

/**
 * 1.16 使用clone(),复制ArrayList的元素
 */
public static void f1_16() {
  // 1.获取数据
  ArrayList<String> arrayList = new ArrayList<>();
  arrayList.add("杭州");
  arrayList.add("苏州");
  arrayList.add("厦门");
  // 2.使用clone
  Object obj = arrayList.clone();
  System.out.println("ArrayList的clone: " + obj);
}

3.增

增，就是增加操作。

3.1操作场景

操作场景，函数功能说明。

(1)使用add,在ArrayList尾部添加元素。

(2)使用add(intindex,Eelement),在指定位置添加元素。

(3)使用addAll(Collection<?extendsE>c),把Collection添加到ArrayList。

(4)使用addAll(intindex,Collection<?extendsE>c),从指定index位置开始添加Collection集合,插入前在index位置及其后面的元素,会存放在插入的Collection后面。

3.2操作实例

操作实例，函数应用实例。

/**
 * 2.1 使用add,在ArrayList尾部添加元素
 */
public static void f2_1() {
  // 1.创建对象和创建元素
  List<GirlVo> list = new ArrayList<>();
  GirlVo girl01 = GirlVo.builder().girlId("1001").girlName("张一").age(27).height(169).cupSize("F").build();
  GirlVo girl02 = GirlVo.builder().girlId("1002").girlName("王二").age(29).height(175).cupSize("B").build();
  GirlVo girl03 = GirlVo.builder().girlId("1003").girlName("刘五").age(24).height(160).cupSize("B").build();
  GirlVo girl04 = GirlVo.builder().girlId("1004").girlName("陈六").age(21).height(168).cupSize("C").build();
  GirlVo girl05 = GirlVo.builder().girlId("1005").girlName("赵七").age(25).height(169).cupSize("C").build();
  GirlVo girl06 = GirlVo.builder().girlId("1006").girlName("张八").age(26).height(165).cupSize("A").build();
  // 2.把元素添加到ArrayList中
  list.add(girl01);
  list.add(girl02);
  list.add(girl03);
  list.add(girl04);
  list.add(girl05);
  list.add(girl06);
  // 3.遍历ArrayList
  for (GirlVo girlVo : list) {
      System.out.println("girlVo信息: " + girlVo);
  }
}

/**
 * 2.2 使用add(int index, E element),在指定位置添加元素.
 * 如果index位置在list中有元素,则新元素占用这个位置.
 * 把原来的元素放到index+1位置
 */
public static void f2_2() {
  // 1.创建对象
  List<String> list = new ArrayList<>();
  // 2.添加数据
  list.add("北京");
  list.add("杭州");
  list.add("厦门");
  System.out.println("调用前遍历: ");
  list.forEach(girl -> {
      System.out.println("girlVo信息: " + girl);
  });
  // 3.指定索引添加数据
  list.add(2, "福州");
  System.out.println("调用后遍历: ");
  list.forEach(girl -> {
      System.out.println("girlVo信息: " + girl);
  });
}

/**
 * 2.3 使用addAll(Collection<? extends E> c),把Collection添加到ArrayList
 */
public static void f2_3() {
  // 1.创建对象
  List<String> list = new ArrayList<>();
  List<String> list01 = new ArrayList<>();
  List<String> list02 = new ArrayList<>();
  // 2.添加数据
  list01.add("北京");
  list01.add("杭州");
  list01.add("厦门");
  list02.add("苏州");
  list02.add("南京");
  list02.add("天津");
  // 3.使用addAll
  list.addAll(list01);
  list.addAll(list02);
  list.forEach(girl -> {
      System.out.println("girlVo信息: " + girl);
  });
}

/**
 * 2.4 使用addAll(int index, Collection<? extends E> c),
 * 从指定index位置开始添加Collection集合,
 * 插入前在index位置及其后面的元素,会存放在插入的Collection后面
 */
public static void f2_4() {
  // 1.创建对象
  List<String> list01 = new ArrayList<>();
  List<String> list02 = new ArrayList<>();
  // 2.添加数据
  list01.add("北京");
  list01.add("杭州");
  list01.add("厦门");
  list02.add("苏州");
  list02.add("南京");
  list02.add("天津");
  // 3.使用addAll
  list01.addAll(1, list02);
  list01.forEach(girl -> {
      System.out.println("girlVo信息: " + girl);
  });
}

4.改

改，就是修改操作。

4.1操作场景

操作场景，函数功能说明。

(1)使用set(intindex,Eelement),修改指定索引的元素如果index位置在list中有元素,则把新元素占用这个位置.原来的元素就没有了。

(2)使用subList(intfromIndex,inttoIndex),截取指定索引范围内的ArrayList。

(3)使用replaceAll(UnaryOperator<E>operator),修改ArrayList内部元素。

(4)使用Object[]toArray(),转换ArrayList为数组。

(5)使用<T>T[]toArray(T[]a),转换ArrayList为数组。

(6)使用for循环,修改ArrayList内部元素。

4.2操作实例

操作实例，函数应用实例。

/**
 * 3.1 使用set(int index, E element),修改指定索引的元素
 * 如果index位置在list中有元素,则把新元素占用这个位置.原来的元素就没有了.
 */
public static void f3_1() {
  // 1.创建对象
  List<String> list = new ArrayList<>();
  // 2.添加数据
  list.add("北京");
  list.add("杭州");
  list.add("厦门");
  System.out.println("调用前遍历: ");
  list.forEach(girl -> {
      System.out.println("girlVo信息: " + girl);
  });
  // 3.修改指定索引元素
  list.set(2, "福州");
  System.out.println("调用后遍历: ");
  list.forEach(girl -> {
      System.out.println("girlVo信息: " + girl);
  });
}

/**
 * 3.2 使用subList(int fromIndex, int toIndex),截取指定索引范围内的ArrayList
 */
public static void f3_2() {
  // 1.创建对象
  List<String> list = new ArrayList<>();
  // 2.添加数据
  list.add("北京");
  list.add("杭州");
  list.add("厦门");
  list.add("苏州");
  list.add("南京");
  System.out.println("调用前遍历: ");
  list.forEach(girl -> {
      System.out.println("girlVo信息: " + girl);
  });
  // 3.截取指定索引范围内元素
  List<String> list01 = list.subList(1, 3);
  System.out.println("调用后遍历: ");
  list01.forEach(girl -> {
      System.out.println("girlVo信息: " + girl);
  });
}

/**
 * 3.3 使用replaceAll(UnaryOperator<E> operator),修改ArrayList内部元素
 * JDK 1.8
 */
public static void f3_3() {
  // 1.获取数据
  List<GirlVo> list = getList();
  System.out.println("操作前遍历信息:");
  list.forEach(girlVo -> {
      System.out.println("girl信息: " + girlVo);
  });
  // 2.修改元素
  list.replaceAll(girlVo -> {
      if (Objects.equals(girlVo.getCupSize(), "B")) {
          girlVo.setCupSize("B+");
      }
      return girlVo;
  });
  System.out.println("操作后遍历信息:");
  list.forEach(girlVo -> {
      System.out.println("girl信息: " + girlVo);
  });
}

/**
 * 3.4 使用Object[] toArray(),转换ArrayList为数组
 */
public static void f3_4() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.使用toArray
  Object[] obj = list.toArray();
  // 3.遍历数据数组
  for (int i = 0; i < obj.length; i++) {
      System.out.println("girl信息: " + obj[i]);
  }
}

/**
 * 3.5 使用<T> T[] toArray(T[] a),转换ArrayList为数组
 */
public static void f3_5() {
  // 1.获取数据
  List<GirlVo> list = getList();
  // 2.使用toArray
  Object[] obj = list.toArray();
  // 3.使用toArray(T[] a)
  Object[] obj02 = list.toArray(obj);
  System.out.println("obj02数组长度: " + obj02.length);
}

/**
 * 3.6 使用for循环,修改ArrayList内部元素
 */
public static void f3_6() {
  // 1.获取数据
  List<GirlVo> list = getList();
  System.out.println("操作前遍历信息:");
  list.forEach(girlVo -> {
      System.out.println("girl信息: " + girlVo);
  });
  // 2.修改元素
  for (GirlVo girlVo : list) {
      if (Objects.equals(girlVo.getCupSize(), "C")) {
          girlVo.setCupSize("C+");
      }
  }
  System.out.println("操作后遍历信息:");
  list.forEach(girlVo -> {
      System.out.println("girl信息: " + girlVo);
  });
}

5.删

删，就是删除操作。

5.1操作场景

操作场景，函数功能说明。

(1)使用remove(intindex),删除指定位置元素。

(2)使用remove(Objecto),删除指定元素。

(3)使用Collection<?>c,删除ArrayList内指定集合内元素。

(4)使用retainAll(Collection<?>c),保留ArrayList内指定集合的数据,其它删除。

(5)使用removeIf(Predicate<?superE>filter),删除符合条件的元素。

(6)使用clear清空ArrayList。

5.2操作实例

操作实例，函数应用实例。

/**
 * 4.1 使用remove(int index),删除指定位置元素
 */
public static void f4_1() {
  // 1.创建对象
  List<String> list = new ArrayList<>();
  // 2.添加数据
  list.add("北京");
  list.add("杭州");
  list.add("厦门");
  System.out.println("调用前遍历: ");
  list.forEach(city -> {
      System.out.println("城市信息: " + city);
  });
  // 3.删除指定索引
  list.remove(1);
  System.out.println("调用后遍历: ");
  list.forEach(city -> {
      System.out.println("城市信息: " + city);
  });
}

/**
 * 4.2 使用remove(Object o),删除指定元素
 */
public static void f4_2() {
  // 1.创建对象
  List<String> list = new ArrayList<>();
  // 2.添加数据
  list.add("北京");
  list.add("杭州");
  list.add("厦门");
  System.out.println("调用前遍历: ");
  list.forEach(girl -> {
      System.out.println("城市信息: " + girl);
  });
  // 3.删除指定元素
  list.remove("杭州");
  System.out.println("调用后遍历: ");
  list.forEach(girl -> {
      System.out.println("城市信息: " + girl);
  });
}

/**
 * 4.3 使用Collection<?> c,删除ArrayList内指定集合内元素
 */
public static void f4_3() {
  // 1.创建对象
  List<String> list = new ArrayList<>();
  List<String> list01 = new ArrayList<>();
  // 2.添加数据
  list.add("北京");
  list.add("杭州");
  list.add("苏州");
  list.add("南京");
  list.add("天津");
  list.add("厦门");
  list01.add("苏州");
  list01.add("南京");
  list01.add("天津");
  System.out.println("调用前遍历: ");
  list.forEach(girl -> {
      System.out.println("城市信息: " + girl);
  });
  // 3.删除指定集合内元素
  list.removeAll(list01);
  System.out.println("调用后遍历: ");
  list.forEach(girl -> {
      System.out.println("城市信息: " + girl);
  });
}

/**
 * 4.4 使用retainAll(Collection<?> c),保留ArrayList内指定集合的数据,其它删除
 */
public static void f4_4() {
  // 1.创建对象
  List<String> list = new ArrayList<>();
  List<String> list01 = new ArrayList<>();
  // 2.添加数据
  list.add("北京");
  list.add("杭州");
  list.add("苏州");
  list.add("南京");
  list.add("天津");
  list.add("厦门");
  list01.add("苏州");
  list01.add("南京");
  list01.add("天津");
  System.out.println("调用前遍历: ");
  list.forEach(girl -> {
      System.out.println("城市信息: " + girl);
  });
  // 3.删除指定集合之外数据
  list.retainAll(list01);
  System.out.println("调用后遍历: ");
  list.forEach(girl -> {
      System.out.println("城市信息: " + girl);
  });
}

/**
 * 4.5 使用removeIf(Predicate<? super E> filter),删除符合条件的元素
 * JDK 1.8
 */
public static void f4_5() {
  // 1.获取数据
  List<GirlVo> list = getList();
  System.out.println("操作前遍历信息:");
  list.forEach(girlVo -> {
      System.out.println("girl信息: " + girlVo);
  });
  // 2.删除符合条件元素
  list.removeIf(girlVo -> {
      return Objects.equals(girlVo.getCupSize(), "B");
  });
  System.out.println("操作后遍历信息:");
  list.forEach(girlVo -> {
      System.out.println("girl信息: " + girlVo);
  });
}

/**
 * 4.6 使用clear清空ArrayList
 */
public static void f4_6() {
  // 1.创建对象
  List<String> list = new ArrayList<>();
  // 2.添加数据
  list.add("北京");
  list.add("杭州");
  list.add("厦门");
  System.out.println("调用前遍历: ");
  list.forEach(city -> {
      System.out.println("城市信息: " + city);
  });
  // 3.清空ArrayList
  list.clear();
  System.out.println("调用后遍历: ");
  list.forEach(city -> {
      System.out.println("城市信息: " + city);
  });
}

6.共用代码

(1)获取List<GirlVo>集合。

/**
 * 获取List<GirlVo>集合
 * */
public static List<GirlVo> getList() {
  List<GirlVo> list = new ArrayList<>();
  GirlVo girl01 = GirlVo.builder().girlId("1001").girlName("张一").age(27).height(169).cupSize("F").build();
  GirlVo girl02 = GirlVo.builder().girlId("1002").girlName("王二").age(29).height(175).cupSize("B").build();
  GirlVo girl03 = GirlVo.builder().girlId("1003").girlName("刘五").age(24).height(160).cupSize("B").build();
  GirlVo girl04 = GirlVo.builder().girlId("1004").girlName("陈六").age(21).height(168).cupSize("C").build();
  GirlVo girl05 = GirlVo.builder().girlId("1005").girlName("赵七").age(25).height(169).cupSize("C").build();
  GirlVo girl06 = GirlVo.builder().girlId("1006").girlName("张八").age(26).height(165).cupSize("A").build();
  list.add(girl01);
  list.add(girl02);
  list.add(girl03);
  list.add(girl04);
  list.add(girl05);
  list.add(girl06);
  return list;
}

(2)GirlVo对象。

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class GirlVo {
  /**ID号*/
  String girlId;
  /**姓名*/
  String girlName;
  /**年龄*/
  long age;
  /**身高*/
  double height;
  /**罩杯*/
  String cupSize;
}

以上，感谢。

2022年8月31日

zhangbeizhen18
关注
  • 1
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java连接MySQL数据库增删改查的通用方法(推荐)
08-29
Java 连接 MySQL 数据库增删改查的通用方法 本篇文章将带领大家实现 Java 连接 MySQL 数据库的增删改查的通用方法。这种方法可以实现对不同数据库的操作，减少代码的冗余和重复。 基本思想 在连接数据库时，我们...
Java集合类之List的ArrayList之增删改查
linsc_05的博客
12-12 845
【代码】Java集合类之List的ArrayList之增删改查。
Java基础（第九期）：Java中的集合 ArrayList && 集合的增删改查 && Java实现学生信息管理系统
Forever_Hopeful的博客
11-25 1196
Java基础（第九期）：Java中的集合 ArrayList && 集合的增删改查 && Java实现学生信息管理系统
Java数据结构之ArrayList（如果想知道Java中有关ArrayList的知识点，那么只看这一篇就足够了！）
秋刀鱼不做梦的编程日常
06-12 2785
Java数据结构之ArrayList（如果想知道Java中有关ArrayList的知识点，那么只看这一篇就足够了！）
Java中的ArrayList替换操作详解
我点评的博客
07-21 3175
可以看到，通过Collections类的replaceAll方法，我们成功地将ArrayList中所有值为\Banana\的元素替换为了新的元素。ArrayList类还提供了replaceAll方法，可以将ArrayList中的所有指定元素替换为新的元素。可以看到，通过replaceAll方法，我们成功地将ArrayList中所有值为\Banana\的元素替换为了新的元素。可以看到，通过set方法，我们成功地将ArrayList中索引为1的元素替换为了新的元素。方法一：使用set方法替换元素。
Java如何修改ArrayList对象中的元素呢？
qq_25073223的博客
10-04 3795
Java修改ArrayList对象中的元素的方法分享
第1关：学习-Java集合类之List的ArrayList之增删改查
m0_73614626的博客
04-13 1173
本关任务：创建 ArrayList 集合并使用它的增删改查方法。接收给定的一行字符串，实现如下需求： 1.通过空格（一个）切割字符串；6.修改集合的第三个元素，改为：list；List 集合用于存储有序的、可以重复的元素，因此我们可以通过索引来访问、遍历元素。ArrayList 是 List 集合的实现类，它的底层数据结构是数组，因此它具有查询快，增删慢的特点。3.使用 size() 方法获取集合长度，配合 for 循环遍历集合。平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。
java期末考试增删改查
最新发布
06-25
5. 集合框架：Java集合框架包括List、Set、Map接口和ArrayList、LinkedList、HashSet、HashMap等实现类，用于存储和管理对象。 6. 线程：Java支持多线程编程，通过Thread类或实现Runnable接口创建线程，实现并发...
JDBC 实现通用的增删改查基础类方法
08-28
BaseDAO 是一个通用的增删改查基础类，使用 Java 语言实现。它提供了基本的数据操作方法，如保存、修改、删除和查询等。BaseDAO 通过反射机制来获取类的信息，并使用 JDBC 连接数据库来执行 SQL 语句。 BaseDAO 的...
jdbc实现连接和增删改查功能
08-26
JDBC 实现连接和增删改查功能 JDBC（Java Data Base Connectivity，java 数据库连接）是一种用于执行 SQL 语句的 Java API，可以为多种关系数据库提供统一访问，它由一组用 Java 语言编写的类和接口组成。JDBC 提供...
jqGrid与java简单的增删改查
11-09
在这个主题中，我们将探讨如何使用jqGrid与Java进行简单的增删改查操作，同时利用jdbc连接数据库，并通过servlet实现前后端交互。 首先，让我们了解一下jqGrid的基本使用。jqGrid的HTML部分通常包括一个`<table>`...
list集合增删改、查询三种方法、list与linked区别以及堆栈和队列、底层去重
qq_66619015的博客
04-08 1022
list集合增删改、查询三种方法、list与linked区别以及堆栈和队列、底层去重
学习-Java集合类之List的ArrayList之增删改查
千浔的博客
04-11 916
本关任务：创建 ArrayList 集合并使用它的增删改查方法。接收给定的一行字符串，实现如下需求： 1.通过空格（一个）切割字符串；4.删除集合的第一个和最后一个元素；6.修改集合的第三个元素，改为：list；List 集合用于存储有序的、可以重复的元素，因此我们可以通过索引来访问、遍历元素。ArrayList 是 List 集合的实现类，它的底层数据结构是数组，因此它具有查询快，增删慢的特点。平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。遍历集合有三种方式： 1.使用迭代器遍历；
Java ArrayList 常用成员方法-增-删-改-查
zc917619462的博客
06-06 791
1.增 : public Boolean add(E e) : 将指定的元素添加到此列表的尾部 public void add(int index,E element) : 在指定索引位置,添加对应的元素(插队) 运行结果 [张三1, 张三2, 张三3] [张三1, 张三2, 李四, 张三3]2.删 : public E remove(int index) :根据索引做删除,返回被删除掉的元素 public boolean remove(Object o): 根据元素删除,返回是否删除成功的状态 运行结果
Java集合——ArrayList的增删改查
与其终的知识小窝
09-29 2432
一、首先new一个最基层的对象 ArrayList list = new ArrayList(); 二、添加内容存入ArrayList集合（增） ArrayList<String> str = new ArrayList<String>(10);//创建一个String类型，<>尖括号里面要填包装类型 str.add("葡萄"); str.add("樱...
Java学习（84）Java集合——案例：公告管理（ArrayList增删改查）
weixin_43360025的博客
01-14 810
Java学习（84）Java集合——案例：公告管理（ArrayList增删改查）
java中Arraylist类的增，删，改，查和遍历
zz3421405093的博客
04-04 318
java中Arraylist类的增，删，改，查和遍历。
Java中集合之ArrayList（方法（增删改查）add、addAll、remove以及它的重载方法、set、get、size(用于遍历)、底层原理）
Jackmat的博客
02-17 489
其中指的是泛型 ，
java不用数据库实现gui增删改查
11-29
在Java中，我们可以使用集合框架（如ArrayList、HashMap等）来实现GUI增删改查功能，而不一定需要依赖数据库。例如，我们可以创建一个ArrayList来存储对象，然后通过GUI界面来添加、删除、修改和查询这些对象。以下是一个简单的示例： 首先，我们可以创建一个包含属性的对象类，比如一个学生类，包括学生的姓名、年龄等信息。 然后，我们可以创建一个ArrayList来存储学生对象，并在GUI界面上实现增删改查的功能。比如，通过按钮来实现添加学生信息、删除选定的学生信息、修改学生信息以及查询学生信息的功能。 在用户点击添加按钮时，程序将会创建一个新的学生对象，并将其添加到ArrayList中；在用户点击删除按钮时，程序将会删除ArrayList中选定的学生对象；在用户点击修改按钮时，程序将会修改ArrayList中选定的学生对象的属性；在用户点击查询按钮时，程序将会根据用户输入的条件，来在ArrayList中查找并展示符合条件的学生对象。 通过以上方法，我们就可以在Java中实现GUI增删改查的功能，而不需要依赖数据库。当然，在实际的应用中，如果涉及到大量的数据存储和复杂的查询操作，数据库仍然是一个更为合适的选择。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值