java 二维数组去除空值
String[][] data = {{“保留”，“”，“”}，{“保留”，“333”，“”}，{“保留”，“555”，“”}，
{“”，“”，“321”}，{“”，“”，“”，“”，“ ”}，{“”，“”，“”}}；
上面代码如何去除空值
变为
String[][] data = {{“保留””}，{“保留”，“333”}，{“保留”，“555”}，{“321”}}；
我们可以统计非空数据，然后创建非空数据的二维数组。最后再遍历原二维数据，填充数据，如下代码
private static String[][] removeEmptyElement(String[][] data) {
// 统计非空元素个数
int nonEmptyCount = 0;
for (String[] row : data) {
for (String element : row) {
if (null != element && !"".equals(element.trim())) {
nonEmptyCount++;
break;
}
}
}
// 创建新的二维数组，存放非空元素
String[][] nonEmptyData = new String[nonEmptyCount][];
int index = 0;
for (String[] row : data) {
List<String> nonEmptyRow = new ArrayList<>();
for (String element : row) {
if (null != element && !"".equals(element.trim())) {
nonEmptyRow.add(element);
}
}
if (nonEmptyRow.size() > 0) {
nonEmptyData[index] = nonEmptyRow.toArray(new String[0]);
index++;
}
}
return nonEmptyData;
}
public static void main(String[] args) {
// 原始二维数组
String[][] data = {
{"保留", "", ""},
{"保留", "333", ""},
{"保留", "555", ""},
{"", "", "321"},
{"", "", "", "", " "},
{"", "", ""}
};
String[][] nonEmptyData = removeEmptyElement(data);
// 打印去除空值后的二维数组
for (String[] row : nonEmptyData) {
System.out.println(Arrays.toString(row));
}
}
如果对你有帮助，麻烦点一下已采纳，谢谢。
import java.util.ArrayList;
import java.util.List;
public class RemoveEmptyValues {
public static void main(String[] args) {
String[][] data = {{"保留", "", ""}, {"保留", "333", ""}, {"保留", "555", ""},
{"", "", "321"}, {"", "", " "}, {"", "", ""}};
String[][] result = removeEmptyValues(data);
for (String[] row : result) {
for (String value : row) {
System.out.print(value + " ");
}
System.out.println();
}
}
public static String[][] removeEmptyValues(String[][] data) {
List<String[]> resultList = new ArrayList<>();
for (String[] row : data) {
List<String> rowList = new ArrayList<>();
for (String value : row) {
if (!value.trim().isEmpty()) {
rowList.add(value);
}
}
resultList.add(rowList.toArray(new String[0]));
}
return resultList.toArray(new String[0][]);
}
}
数组本身是定长的，不可更改
你可以换成list，就可以删除空值
要么你就要重新定义一个二维数组，然后先遍历一遍到底有多少非空，确定数组长度，再遍历一遍赋值
方式一：继承Thread
继承Thread，重写里面run方法，创建实例，执行start
优点：代码编写最简单直接操作
缺点：没返回值，继承一个类后，没法继承其他的类，拓展性差
public class ThreadDemo1 extends Thread {
@Override
public void run() {
System.out.println("继承Thread实现多线程，名称："+Thread.currentThread().getName());
}
}
public static void main(String[] args) {
ThreadDemo1 threadDemo1 = new ThreadDemo1();
threadDemo1.setName("demo1");
threadDemo1.start();
System.out.println("主线程名称："+Thread.currentThread().getName());
}
方式二：实现Runnable接口
自定义类实现Runnable，实现里面run方法，创建Thread类，使用Runnable接口的实现对象作为参数传递给Thread对象，调用Strat方法
优点：线程类可以实现多个几接口，可以再继承一个类
缺点：没返回值，不能直接启动，需要通过构造一个Thread实例传递进去启动
public class ThreadDemo2 implements Runnable {
@Override
public void run() {
System.out.println("通过Runnable实现多线程，名称："+Thread.currentThread().getName());
}
}
public static void main(String[] args) {
ThreadDemo2 threadDemo2 = new ThreadDemo2();
Thread thread = new Thread(threadDemo2);
thread.setName("demo2");
thread.start();
System.out.println("主线程名称："+Thread.currentThread().getName());
}
JDK8之后采用lambda表达式
public static void main(String[] args) {
Thread thread = new Thread(()->{
System.out.println("通过Runnable实现多线程，名称："+Thread.currentThread().getName());
});
thread.setName("demo2");
thread.start();
System.out.println("主线程名称："+Thread.currentThread().getName());
}
方式三：通过Callable和FutureTask方式
创建callable接口的实现类，并实现call方法，结合FutureTask类包装Callable对象，实现多线程
优点：有返回值，拓展性也高
缺点：jdk5以后才支持，需要重写call方法，结合多个类比如FutureTask和Thread类
public class MyTask implements Callable<Object> {
@Override
public Object call() throws Exception {
System.out.println("通过Callable实现多线程，名称："+Thread.currentThread().getName());
return "这是返回值";
}
}
public static void main(String[] args) {
FutureTask<Object> futureTask = new FutureTask<>(()->{
System.out.println("通过Callable实现多线程，名称："+Thread.currentThread().getName());
return "这是返回值";
});
// MyTask myTask = new MyTask();
// FutureTask<Object> futureTask = new FutureTask<>(myTask);
//FutureTask继承了Runnable，可以放在Thread中启动执行
Thread thread = new Thread(futureTask);
thread.setName("demo3");
thread.start();
System.out.println("主线程名称:"+Thread.currentThread().getName());
try {
System.out.println(futureTask.get());
} catch (InterruptedException e) {
//阻塞等待中被中断，则抛出
e.printStackTrace();
} catch (ExecutionException e) {
//执行过程发送异常被抛出
e.printStackTrace();
}
}
方式四：通过线程池创建线程
自定义Runnable接口，实现run方法，创建线程池，调用执行方法并传入对象
优点：安全高性能，复用线程
缺点: jdk5后才支持，需要结合Runnable进行使用
public class ThreadDemo4 implements Runnable {
@Override
public void run() {
System.out.println("通过线程池+runnable实现多线程，名称："+Thread.currentThread().getName());
}
}
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(3);
for(int i=0;i<10;i++){
executorService.execute(new ThreadDemo4());
}
System.out.println("主线程名称:"+Thread.currentThread().getName());
//关闭线程池
executorService.shutdown();
}