java版js数组

最新推荐文章于 2024-06-28 09:52:57 发布
最新推荐文章于 2024-06-28 09:52:57 发布
阅读量365 收藏
点赞数
分类专栏： java 数据结构和算法 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhoujiaping123/article/details/84842899
版权

背景：
java数组、列表的抽象程度不够，操作起来相对麻烦。相比而言，js数组方便很多。于是参考js的数组api，对java数组（列表）进行抽象，可以非常方便地进行平常的一些操作。
依赖：
只是在toString方法中依赖了fastjson，所以就不贴pom.xml了。
代码：
1、接口

package org.jsirenia.array;

import java.util.Comparator;
import java.util.List;
import java.util.Map;

import org.jsirenia.util.callback.Callback11;
import org.jsirenia.util.callback.Callback20;
import org.jsirenia.util.callback.Callback21;
import org.jsirenia.util.callback.Callback30;
import org.jsirenia.util.callback.Callback31;
import org.jsirenia.util.callback.Callback41;

public interface Array<T> extends Iterable<T>{
		public List<T> toList();
		public <E> Array<E> map(Callback11<E,T> cb);
		public <E> Array<E> map(Callback21<E,T,Integer> cb);
		public <E> Array<E> map(Callback31<E,T,Integer,Array<T>> cb);
		public Object[] toArray();
		public T[] toArray(Class<T> clazz);
		public T reduce(Callback31<T,T,T,Integer> cb,T initValue);
		public T reduce(Callback41<T,T,T,Integer,Array<T>> cb,T initValue);
		public T reduce(Callback21<T,T,T> cb,T initValue);
		public Array<T> filter(Callback11<Boolean,T> cb);
		public Array<T> filter(Callback21<Boolean,T,Integer> cb);
		public Array<T> filter(Callback31<Boolean,T,Integer,Array<T>> cb);
		public <R> Map<R,Array<T>> groupBy(Callback11<R,T> cb);
		public <R> Map<R,Array<T>> groupBy(Callback21<R,T,Integer> cb);
		public <R> Map<R,Array<T>> groupBy(Callback31<R,T,Integer,Array<T>> cb);
		public String join();
		public String join(String seperator);
		public boolean every(Callback31<Boolean,T,Integer,Array<T>> cb);
		public boolean every(Callback21<Boolean,T,Integer> cb);
		public boolean every(Callback11<Boolean,T> cb);
		public boolean some(Callback31<Boolean,T,Integer,Array<T>> cb);
		public boolean some(Callback21<Boolean,T,Integer> cb);
		public boolean some(Callback11<Boolean,T> cb);
		public int push(T v1,T v2,T v3,T v4,T v5,T v6,T v7,T v8,T v9,T v10);
		public int push(T v1,T v2,T v3,T v4,T v5,T v6,T v7,T v8,T v9);
		public int push(T v1,T v2,T v3,T v4,T v5,T v6,T v7,T v8);
		public int push(T v1,T v2,T v3,T v4,T v5,T v6,T v7);
		public int push(T v1,T v2,T v3,T v4,T v5,T v6);
		public int push(T v1,T v2,T v3,T v4,T v5);
		public int push(T v1,T v2,T v3,T v4);
		public int push(T v1,T v2,T v3);
		public int push(T v1,T v2);
		public int push(T v1);
		public T pop();
		public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4,Array<T> a5,Array<T> a6,Array<T> a7,Array<T> a8,Array<T> a9,Array<T> a10);
		public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4,Array<T> a5,Array<T> a6,Array<T> a7,Array<T> a8,Array<T> a9);
		public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4,Array<T> a5,Array<T> a6,Array<T> a7,Array<T> a8);
		public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4,Array<T> a5,Array<T> a6,Array<T> a7);
		public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4,Array<T> a5,Array<T> a6);
		public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4,Array<T> a5);
		public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4);
		public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3);
		public Array<T> concat(Array<T> a1,Array<T> a2);
		public Array<T> concat(Array<T> a1);
		public Array<T> concat(T v1,T v2,T v3,T v4,T v5,T v6,T v7,T v8,T v9,T v10);
		public Array<T> concat(T v1,T v2,T v3,T v4,T v5,T v6,T v7,T v8,T v9);
		public Array<T> concat(T v1,T v2,T v3,T v4,T v5,T v6,T v7,T v8);
		public Array<T> concat(T v1,T v2,T v3,T v4,T v5,T v6,T v7);
		public Array<T> concat(T v1,T v2,T v3,T v4,T v5,T v6);
		public Array<T> concat(T v1,T v2,T v3,T v4,T v5);
		public Array<T> concat(T v1,T v2,T v3,T v4);
		public Array<T> concat(T v1,T v2,T v3);
		public Array<T> concat(T v1,T v2);
		public Array<T> concat(T v1);
		public int unshift();
		public T shift();
		public Array<T> splice();
		public Array<T> slice(int start);
		public Array<T> slice(int start, int end);
		public void sort(Comparator<? super T> c);
		public void sort();
		public Array<T> reverse();
		public T reduceRight(Callback41<T,T,T,Integer,Array<T>> cb,T initValue);
		public T reduceRight(Callback31<T,T,T,Integer> cb,T initValue);
		public T reduceRight(Callback21<T,T,T> cb,T initValue);
		public int lastIndexOf(T t);
		public int indexOf(T t);
		public T find(Callback11<Boolean,T> cb);
		public int findIndex(Callback11<Boolean,T> cb);
		public Array<T> fill(T t,int start,int end);
		public void forEach(Callback20<T,Integer> cb);
		public void forEach(Callback30<T,Integer,Array<T>> cb);
		public boolean inclueds();
		public Array<Integer> keys();
	}

2、实现

package org.jsirenia.array;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.jsirenia.util.callback.Callback11;
import org.jsirenia.util.callback.Callback20;
import org.jsirenia.util.callback.Callback21;
import org.jsirenia.util.callback.Callback30;
import org.jsirenia.util.callback.Callback31;
import org.jsirenia.util.callback.Callback41;

import com.alibaba.fastjson.JSONArray;
/**
 * 非常方便进行map,reduce,filter等操作。js版数组
 * 性能嘛，当然和java的stream没法比。
 * 挺有意思的，操作数据很6很方便
 */
public class JArray<T> implements Array<T>{
	private List<T> list;
	public JArray(){
		list = new ArrayList<>();
	}
	public static <E> JArray<E> of(List<E> list){
		JArray<E> array = new JArray<>();
		array.list = list;
		return array;
	}
	@SafeVarargs
	public static <E> JArray<E> of(E... objects){
		JArray<E> array = new JArray<>();
		array.list = new ArrayList<>();
		if(objects==null){
			return array;
		}
		for(int i=0;i<objects.length;i++){
			array.list.add(objects[i]);
		}
		return array;
	}
	@Override
	public List<T> toList(){
		return list;
	}
	@Override
	public <E> Array<E> map(Callback11<E,T> cb){
		List<E> localList = new ArrayList<>();
		for(int i=0;i<list.size();i++){
			localList.add(cb.apply(list.get(i)));
		}
		return JArray.of(localList);
	}
	@Override
	public <E> Array<E> map(Callback21<E,T,Integer> cb){
		List<E> localList = new ArrayList<>();
		for(int i=0;i<list.size();i++){
			localList.add(cb.apply(list.get(i),i));
		}
		return JArray.of(localList);
	}
	@Override
	public <E> Array<E> map(Callback31<E,T,Integer,Array<T>> cb){
		List<E> localList = new ArrayList<>();
		for(int i=0;i<list.size();i++){
			localList.add(cb.apply(list.get(i),i,this));
		}
		return JArray.of(localList);
	}
	@Override
	public Object[] toArray(){
		return (Object[]) java.lang.reflect.Array.newInstance(Object.class, list.size());
	}
	@Override
	@SuppressWarnings("unchecked")
	public T[] toArray(Class<T> clazz){
		T[] array = (T[]) java.lang.reflect.Array.newInstance(clazz, list.size());
		for(int i=0;i<array.length;i++){
			array[i] = list.get(i);
		}
		return array;
	}
	@Override
	public T reduce(Callback31<T,T,T,Integer> cb,T initValue){
		T v = initValue;
		for(int i=0;i<list.size();i++){
			v = cb.apply(v, list.get(i), i);
		}
		return v;
	}
	@Override
	public T reduce(Callback41<T,T,T,Integer,Array<T>> cb,T initValue){
		T v = initValue;
		for(int i=0;i<list.size();i++){
			v = cb.apply(v, list.get(i), i ,this);
		}
		return v;
	}
	@Override
	public T reduce(Callback21<T,T,T> cb,T initValue){
		T v = initValue;
		for(int i=0;i<list.size();i++){
			v = cb.apply(v, list.get(i));
		}
		return v;
	}
	@Override
	public Array<T> filter(Callback11<Boolean,T> cb){
		List<T> newList = new ArrayList<>(list.size());
		T v = null;
		for(int i=0;i<list.size();i++){
			v = list.get(i);
			if(cb.apply(v)){
				newList.add(v);
			}
		}
		JArray<T> array = new JArray<>();
		array.list = newList;
		return array;
	}
	@Override
	public Array<T> filter(Callback21<Boolean,T,Integer> cb){
		List<T> newList = new ArrayList<>(list.size());
		T v = null;
		for(int i=0;i<list.size();i++){
			v = list.get(i);
			if(cb.apply(v,i)){
				newList.add(v);
			}
		}
		JArray<T> array = new JArray<>();
		array.list = newList;
		return array;
	}
	@Override
	public Array<T> filter(Callback31<Boolean,T,Integer,Array<T>> cb){
		List<T> newList = new ArrayList<>(list.size());
		T v = null;
		for(int i=0;i<list.size();i++){
			v = list.get(i);
			if(cb.apply(v,i,this)){
				newList.add(v);
			}
		}
		JArray<T> array = new JArray<>();
		array.list = newList;
		return array;
	}
	@Override
	public <R> Map<R,Array<T>> groupBy(Callback11<R,T> cb){
		Map<R,Array<T>> map = new HashMap<>();
		T v;
		R k;
		Array<T> array;
		for(int i=0;i<list.size();i++){
			v = list.get(i);
			k = cb.apply(v);
			array = map.get(k);
			if(array==null){
				array = JArray.of();
				map.put(k, array);
			}
			array.push(v);
		}
		return map;
	}
	@Override
	public <R> Map<R,Array<T>> groupBy(Callback21<R,T,Integer> cb){
		Map<R,Array<T>> map = new HashMap<>();
		T v;
		R k;
		Array<T> array;
		for(int i=0;i<list.size();i++){
			v = list.get(i);
			k = cb.apply(v,i);
			array = map.get(k);
			if(array==null){
				array = JArray.of();
				map.put(k, array);
			}
			array.push(v);
		}
		return map;
	}
	@Override
	public <R> Map<R,Array<T>> groupBy(Callback31<R,T,Integer,Array<T>> cb){
		Map<R,Array<T>> map = new HashMap<>();
		T v;
		R k;
		Array<T> array;
		for(int i=0;i<list.size();i++){
			v = list.get(i);
			k = cb.apply(v,i,this);
			array = map.get(k);
			if(array==null){
				array = JArray.of();
				map.put(k, array);
			}
			array.push(v);
		}
		return map;
	}
	@Override
	public String join(){
		return join(",");
	}
	@Override
	public String join(String seperator){
		StringBuilder sb = new StringBuilder();
		Iterator<T> iter = this.iterator();
		T t;
		if(iter.hasNext()){
			t = iter.next();
			sb.append(String.valueOf(t));
		}
		while(iter.hasNext()){
			t = iter.next();
			sb.append(seperator).append(String.valueOf(t));
		}
		return sb.toString();
	}
	@Override
	public boolean every(Callback31<Boolean,T,Integer,Array<T>> cb){
		for(int i=0;i<list.size();i++){
			if(!cb.apply(list.get(i), i, this)){
				return false;
			}
		}
		return true;
	}
	@Override
	public boolean every(Callback21<Boolean,T,Integer> cb){
		for(int i=0;i<list.size();i++){
			if(!cb.apply(list.get(i), i)){
				return false;
			}
		}
		return true;
	}
	@Override
	public boolean every(Callback11<Boolean,T> cb){
		for(int i=0;i<list.size();i++){
			if(!cb.apply(list.get(i))){
				return false;
			}
		}
		return true;
	}
	@Override
	public boolean some(Callback31<Boolean,T,Integer,Array<T>> cb){
		for(int i=0;i<list.size();i++){
			if(cb.apply(list.get(i),i,this)){
				return true;
			}
		}
		return false;
	}
	@Override
	public boolean some(Callback21<Boolean,T,Integer> cb){
		for(int i=0;i<list.size();i++){
			if(cb.apply(list.get(i),i)){
				return true;
			}
		}
		return false;
	}
	@Override
	public boolean some(Callback11<Boolean,T> cb){
		for(int i=0;i<list.size();i++){
			if(cb.apply(list.get(i))){
				return true;
			}
		}
		return false;
	}
	@Override
	public int push(T v1,T v2,T v3,T v4,T v5,T v6,T v7,T v8,T v9,T v10){
		list.add(v1);
		list.add(v2);
		list.add(v3);
		list.add(v4);
		list.add(v5);
		list.add(v6);
		list.add(v7);
		list.add(v8);
		list.add(v9);
		list.add(v10);
		return list.size();
	}
	@Override
	public int push(T v1,T v2,T v3,T v4,T v5,T v6,T v7,T v8,T v9){
		list.add(v1);
		list.add(v2);
		list.add(v3);
		list.add(v4);
		list.add(v5);
		list.add(v6);
		list.add(v7);
		list.add(v8);
		list.add(v9);
		return list.size();
	}
	@Override
	public int push(T v1,T v2,T v3,T v4,T v5,T v6,T v7,T v8){
		list.add(v1);
		list.add(v2);
		list.add(v3);
		list.add(v4);
		list.add(v5);
		list.add(v6);
		list.add(v7);
		list.add(v8);
		return list.size();
	}
	@Override
	public int push(T v1,T v2,T v3,T v4,T v5,T v6,T v7){
		list.add(v1);
		list.add(v2);
		list.add(v3);
		list.add(v4);
		list.add(v5);
		list.add(v6);
		list.add(v7);
		return list.size();
	}
	@Override
	public int push(T v1,T v2,T v3,T v4,T v5,T v6){
		list.add(v1);
		list.add(v2);
		list.add(v3);
		list.add(v4);
		list.add(v5);
		list.add(v6);
		return list.size();
	}
	@Override
	public int push(T v1,T v2,T v3,T v4,T v5){
		list.add(v1);
		list.add(v2);
		list.add(v3);
		list.add(v4);
		list.add(v5);
		return list.size();
	}
	@Override
	public int push(T v1,T v2,T v3,T v4){
		list.add(v1);
		list.add(v2);
		list.add(v3);
		list.add(v4);
		return list.size();
	}
	@Override
	public int push(T v1,T v2,T v3){
		list.add(v1);
		list.add(v2);
		list.add(v3);
		return list.size();
	}
	@Override
	public int push(T v1,T v2){
		list.add(v1);
		list.add(v2);
		return list.size();
	}
	@Override
	public int push(T v1){
		list.add(v1);
		return list.size();
	}
	@Override
	public T pop(){
		return list.remove(list.size()-1);
	}
	//最多支持10个元素。可变参数版本调用方也会有警告，哎！
	@Override
	@SuppressWarnings("unchecked")
	public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4,Array<T> a5,Array<T> a6,Array<T> a7,Array<T> a8,Array<T> a9,Array<T> a10){
		return concat(new Array[]{a1,a2,a3,a4,a5,a6,a7,a8,a9,a10});
	}
	@Override
	@SuppressWarnings("unchecked")
	public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4,Array<T> a5,Array<T> a6,Array<T> a7,Array<T> a8,Array<T> a9){
		return concat(new Array[]{a1,a2,a3,a4,a5,a6,a7,a8,a9});
	}
	@Override
	@SuppressWarnings("unchecked")
	public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4,Array<T> a5,Array<T> a6,Array<T> a7,Array<T> a8){
		return concat(new Array[]{a1,a2,a3,a4,a5,a6,a7,a8});
	}
	@Override
	@SuppressWarnings("unchecked")
	public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4,Array<T> a5,Array<T> a6,Array<T> a7){
		return concat(new Array[]{a1,a2,a3,a4,a5,a6,a7});
	}
	@Override
	@SuppressWarnings("unchecked")
	public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4,Array<T> a5,Array<T> a6){
		return concat(new Array[]{a1,a2,a3,a4,a5,a6});
	}
	@Override
	@SuppressWarnings("unchecked")
	public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4,Array<T> a5){
		return concat(new Array[]{a1,a2,a3,a4,a5});
	}
	@Override
	@SuppressWarnings("unchecked")
	public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3,Array<T> a4){
		return concat(new Array[]{a1,a2,a3,a4});
	}
	@Override
	@SuppressWarnings("unchecked")
	public Array<T> concat(Array<T> a1,Array<T> a2,Array<T> a3){
		return concat(new Array[]{a1,a2,a3});
	}
	@Override
	@SuppressWarnings("unchecked")
	public Array<T> concat(Array<T> a1,Array<T> a2){
		return concat(new Array[]{a1,a2});
	}
	@Override
	//只有一个的情况，优化一下，这种情况使用概率较高
	public Array<T> concat(Array<T> a1){
		List<T> newList = new ArrayList<>(list.size()+a1.toList().size());
		newList.addAll(list);
		newList.addAll(a1.toList());
		return JArray.of(newList);
	}
	private Array<T> concat(Array<T>[] anothers){
		int size = list.size();
		for(int i=0;i<anothers.length;i++){
			size+=anothers[i].toList().size();
		}
		List<T> newList = new ArrayList<>(size);
		newList.addAll(list);
		for(int i=0;i<anothers.length;i++){
			newList.addAll(anothers[i].toList());
		}
		return JArray.of(newList);
	}
	@Override
	public Array<T> concat(T v1,T v2,T v3,T v4,T v5,T v6,T v7,T v8,T v9,T v10){
		List<T> newList = new ArrayList<>(list.size()+10);
		newList.addAll(list);
		newList.add(v1);
		newList.add(v2);
		newList.add(v3);
		newList.add(v4);
		newList.add(v5);
		newList.add(v6);
		newList.add(v7);
		newList.add(v8);
		newList.add(v9);
		newList.add(v10);
		return JArray.of(newList);
	}
	@Override
	public Array<T> concat(T v1,T v2,T v3,T v4,T v5,T v6,T v7,T v8,T v9){
		List<T> newList = new ArrayList<>(list.size()+9);
		newList.addAll(list);
		newList.add(v1);
		newList.add(v2);
		newList.add(v3);
		newList.add(v4);
		newList.add(v5);
		newList.add(v6);
		newList.add(v7);
		newList.add(v8);
		newList.add(v9);
		return JArray.of(newList);
	}
	@Override
	public Array<T> concat(T v1,T v2,T v3,T v4,T v5,T v6,T v7,T v8){
		List<T> newList = new ArrayList<>(list.size()+8);
		newList.addAll(list);
		newList.add(v1);
		newList.add(v2);
		newList.add(v3);
		newList.add(v4);
		newList.add(v5);
		newList.add(v6);
		newList.add(v7);
		newList.add(v8);
		return JArray.of(newList);
	}
	@Override
	public Array<T> concat(T v1,T v2,T v3,T v4,T v5,T v6,T v7){
		List<T> newList = new ArrayList<>(list.size()+7);
		newList.addAll(list);
		newList.add(v1);
		newList.add(v2);
		newList.add(v3);
		newList.add(v4);
		newList.add(v5);
		newList.add(v6);
		newList.add(v7);
		return JArray.of(newList);
	}
	@Override
	public Array<T> concat(T v1,T v2,T v3,T v4,T v5,T v6){
		List<T> newList = new ArrayList<>(list.size()+6);
		newList.addAll(list);
		newList.add(v1);
		newList.add(v2);
		newList.add(v3);
		newList.add(v4);
		newList.add(v5);
		newList.add(v6);
		return JArray.of(newList);
	}
	@Override
	public Array<T> concat(T v1,T v2,T v3,T v4,T v5){
		List<T> newList = new ArrayList<>(list.size()+5);
		newList.addAll(list);
		newList.add(v1);
		newList.add(v2);
		newList.add(v3);
		newList.add(v4);
		newList.add(v5);
		return JArray.of(newList);
	}
	@Override
	public Array<T> concat(T v1,T v2,T v3,T v4){
		List<T> newList = new ArrayList<>(list.size()+4);
		newList.addAll(list);
		newList.add(v1);
		newList.add(v2);
		newList.add(v3);
		newList.add(v4);
		return JArray.of(newList);
	}
	@Override
	public Array<T> concat(T v1,T v2,T v3){
		List<T> newList = new ArrayList<>(list.size()+3);
		newList.addAll(list);
		newList.add(v1);
		newList.add(v2);
		newList.add(v3);
		return JArray.of(newList);
	}
	@Override
	public Array<T> concat(T v1,T v2){
		List<T> newList = new ArrayList<>(list.size()+2);
		newList.addAll(list);
		newList.add(v1);
		newList.add(v2);
		return JArray.of(newList);
	}
	@Override
	public Array<T> concat(T v1){
		List<T> newList = new ArrayList<>(list.size()+1);
		newList.addAll(list);
		newList.add(v1);
		return JArray.of(newList);
	}
	/*private Array<T> concat(T[] values){
		if(values==null){
			throw new RuntimeException("anothers can not be null");
		}
		List<T> newList = new ArrayList<>(list.size()+values.length);
		newList.addAll(list);
		for(int i=0;i<values.length;i++){
			newList.add(values[i]);
		}
		return JArray.of(newList);
	}*/
	@Override
	public int unshift(){
		throw new RuntimeException("method unshift is not supported!");
	}
	@Override
	public T shift(){
		throw new RuntimeException("method shift is not supported!");
	}
	@Override
	public Array<T> splice(){
		throw new RuntimeException("method splice is not supported!");
	}
	@Override
	public Array<T> slice(int start){
		return slice(start,list.size());
	}
	@Override
	public Array<T> slice(int start, int end){
		int size = list.size();
		if(start<0){
			start = start+size;
		}
		if(end<0){
			end = end+size; 
		}
		int newSize = end-start;
		List<T> newList = null;
		if(newSize>0){
			newList = new ArrayList<>(newSize);
		}else{
			newList = new ArrayList<>();
		}
		for(int i=start;i<end;i++){
			newList.add(list.get(i));
		}
		return JArray.of(newList);
	}
	@Override
	public void sort(Comparator<? super T> c){
		list.sort(c);
	}
	@Override
	@SuppressWarnings("unchecked")
	public void sort(){
		list.sort((v1,v2)->{
			Comparable<T> c1 = (Comparable<T>) v1;
			return c1.compareTo(v2);
		});
	}
	@Override
	public Array<T> reverse(){
		Collections.reverse(list);
		return this;
	}
	@Override
	public T reduceRight(Callback41<T,T,T,Integer,Array<T>> cb,T initValue){
		T v = initValue;
		for(int i=list.size()-1;i>=0;i--){
			v = cb.apply(v, list.get(i), i ,this);
		}
		return v;
	}
	@Override
	public T reduceRight(Callback31<T,T,T,Integer> cb,T initValue){
		T v = initValue;
		for(int i=list.size()-1;i>=0;i--){
			v = cb.apply(v, list.get(i), i);
		}
		return v;
	}
	@Override
	public T reduceRight(Callback21<T,T,T> cb,T initValue){
		T v = initValue;
		for(int i=list.size()-1;i>=0;i--){
			v = cb.apply(v, list.get(i));
		}
		return v;
	}
	@Override
	public int lastIndexOf(T t){
		return list.lastIndexOf(t);
	}
	@Override
	public int indexOf(T t){
		return list.indexOf(t);
	}
	@Override
	public T find(Callback11<Boolean,T> cb){
		for(int i=0;i<list.size();i++){
			if(cb.apply(list.get(i))){
				return list.get(i);
			}
		}
		return null;
	}
	@Override
	public int findIndex(Callback11<Boolean,T> cb){
		for(int i=0;i<list.size();i++){
			if(cb.apply(list.get(i))){
				return i;
			}
		}
		return -1;
	}
	@Override
	public Array<T> fill(T t,int start,int end){
		int size = list.size();
		if(start<0){
			start = start+size;
		}
		if(end<0){
			end = end+size; 
		}
		for(int i=start;i<end;i++){
			list.set(i, t);
		}
		return this;
	}
	@Override
	public void forEach(Callback20<T,Integer> cb){
		for(int i=0;i<list.size();i++){
			cb.apply(list.get(i),i);
		}
	}
	@Override
	public void forEach(Callback30<T,Integer,Array<T>> cb){
		for(int i=0;i<list.size();i++){
			cb.apply(list.get(i),i,this);
		}
	}
	@Override
	public boolean inclueds(){
		throw new RuntimeException("method inclueds is not supported!");
	}
	@Override
	public Array<Integer> keys(){
		throw new RuntimeException("method keys is not supported!");
	}
	@Override
	public Iterator<T> iterator() {
		return list.listIterator();
	}
	@Override
	public String toString(){
		return JSONArray.toJSONString(list);
	}
	public static <E> Array<E> fromString(String str,Class<E> clazz){
		return JArray.of(JSONArray.parseArray(str, clazz));
	}
	public static Array<String> split(String text,String sepratorReg){
		String[] arr = text.split(sepratorReg);
		return JArray.of(arr);
	}
}

3、工具类
3.1

package org.jsirenia.util.callback;
/**
 * 0个入参，没有返回值
 */
@FunctionalInterface
public interface Callback00{
	public void apply();
}

3.2

package org.jsirenia.util.callback;
/**
 * 0个入参，1个返回值
 */
@FunctionalInterface
public interface Callback01<T>{
	public T apply();
}

3.3

package org.jsirenia.util.callback;
/**
 * 1个入参，没有返回值
 */
@FunctionalInterface
public interface Callback10<T>{
	public void apply(T t);
}

3.4

package org.jsirenia.util.callback;
@FunctionalInterface
public interface Callback11<R,T>{
	public R apply(T t);
}

3.5

package org.jsirenia.util.callback;
/**
 * 2个入参，没有返回值
 */
@FunctionalInterface
public interface Callback20<T1,T2>{
	public void apply(T1 t1,T2 t2);
}

3.6

package org.jsirenia.util.callback;
@FunctionalInterface
public interface Callback21<R,T1,T2>{
	public R apply(T1 t1,T2 t2);
}

3.7

package org.jsirenia.util.callback;
/**
 * 3个入参，没有返回值
 */
@FunctionalInterface
public interface Callback30<T1,T2,T3>{
	public void apply(T1 t1,T2 t2,T3 t3);
}

3.8

package org.jsirenia.util.callback;
/**
 * 3个入参，1个返回值
 */
@FunctionalInterface
public interface Callback31<R,T1,T2,T3>{
	public R apply(T1 t1,T2 t2,T3 t3);
}

3.9

package org.jsirenia.util.callback;
/**
 * 3个入参，1个返回值
 */
@FunctionalInterface
public interface Callback41<R,T1,T2,T3,T4>{
	public R apply(T1 t1,T2 t2,T3 t3,T4 t4);
}

4.测试

public static void main(String[] args) {
		String[] array = JArray.of("hello","world").toArray(String.class);
		System.out.println(array);
		JArray<String> jarray = JArray.of("hello","world","jsirenia");
		String res = jarray.filter(i->i.contains("l")).map(t->{
			return t.toUpperCase();
		}).reduce((prev,curr)->prev+" "+curr, "");
		System.out.println(res);
		for(String item : jarray){
			System.out.println(item);
		}
		JArray<String> jarray2 = JArray.of(new String[]{"hello","hworld","jsirenia"});
		System.out.println(jarray2.join(","));
		String s = jarray.concat(jarray2).join(",");
		System.out.println(s);
		
		jarray.sort();
		System.out.println(jarray.join());
		
		Map<String,Array<String>> map = jarray2.groupBy(t->{
			return t.charAt(0)+"";
		});
		System.out.println(map);
	}
(def p [])
关注
专栏目录
Java执行JS
xusanyao的博客
06-24 812
1 创建java类 package com.common.util; import javax.script.Invocable; import javax.script.ScriptEngine; import javax.script.ScriptEngineManager; import javax.script.ScriptException; import java.io.*; ...
java数组和js数组
hujinyuan的博客
12-19 1071
java定义数组的几种方法 String[] aArray = new String[5];   String[] bArray = {"a","b","c", "d", "e"};   String[] cArray = new String[]{"a","b","c","d","e"}; js数组 var mycars=new Array() myc
【JAVA】Java中运行JS代码
最新发布
tr6666的博客
06-28 840
在日常的开发工作中，我们可能会遇到需要在Java代码中运行JavaScript代码的情况。虽然Java和JavaScript是两种完全不同的编程语言，但Java提供了一种机制来执行JavaScript代码。在本文中，我们将探讨如何在Java中运行JavaScript代码。在本文中，我们讨论了如何在Java中运行JavaScript代码，包括相关类的解释以及代码的实现。虽然这个示例很简单，但它展示了在Java中运行JavaScript代码的基本方法。
java解析js数组数据
iteye_16532的博客
11-26 619
js代码如下： var at_arrEle11 = new Array;at_arrEle11[0] = new Array("4","舞街区")at_arrEle11[1] = new Array("1","航海世纪")at_arrEle11[2] = new Array("9","英雄之城")at_arrEle11[3] = new Array("7",&quot
java js 数组_[Java教程]JS数组方法
weixin_35012535的博客
02-22 76
[Java教程]JS数组方法0 2016-09-09 17:00:08 var a = [1,2,3,4,5,6]; var b = a.some(function(ele,index,arr){ console.log(ele);//输出1,2,3遍历到3停止遍历 return ele > 2; }); alert(b);...
java javascript数组_JavaScript中Array（数组）的属性和方法 .
weixin_32001433的博客
02-24 208
数组有四种定义的方式使用构造函数：var a = new Array();var b = new Array(8);var c = new Array("first", "second", "third");或者数组直接量：var d = ["first", "second", "third"];属性Array只有一个属性，就是length，length表示的是数组所占内存空间的数目，而不仅仅是数...
js接收并转化Java中的数组对象的方法
10-21
在解析之后，`addVehicleArray`就是一个JavaScript对象数组，可以按照普通JavaScript数组的方式进行操作。 **代码示例** 假设我们已经通过某种方式获取了`szJsonStr`字符串，我们可以这样解析并使用： ```...
java集合与数组的相同点和不同点
08-26
在Java编程语言中，数组和集合都是用于存储和管理数据的结构，但它们在功能、灵活性和使用场景上存在显著的差异。以下是关于Java集合与数组的相同点和不同点的详细说明： 相同点： 1. 容器：无论是数组还是集合，...
java实现二维数组转json的方法示例
10-19
在Java编程中，将二维数组转换为JSON格式的数据是常见的数据处理需求，特别是在处理Web服务或数据交换时。本文将详细讲解如何使用Java实现这一功能，以及涉及的相关操作技巧。 首先，我们需要理解二维数组和JSON的...
浅谈javascript和java中的数组
01-20
　直接创建方式 var str = ['java'， 'js']; 　使用new创建方式： var a = new Array(10); // 定义长度为10的数组（可变） 　另类new创建方式：var a = new Array(1， 2， 3， 4， 5); var b = [1， 2， 3， ...
java提取json中某个数组的所有值方法
10-18
在Java编程中，处理JSON数据是一项常见的任务。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，广泛用于Web服务和...希望这个示例能帮助你理解Java中提取JSON数组值的过程，并在你的项目中派上用场。
JS和JAVA中的数组
weixin_42533428的博客
05-19 437
（1）静态初始化//数据类型 数组名称[] = {值列表}（2）动态初始化//数据类型 数组名称[] = new 数据类型（数组长度）let 数组名称 = [数据1，数据2，...]数组中可以是任意类型的数据Java中的数组与JS中的数组的取值、修改、遍历都是相同的，只有定义的是有区别的，JS中定义要用关键词let，数组内可以存放任何类型的数据。同时，Java中的常用方法和JS中的常用方法大致相同，只有小部分有区别。
js和java中数组的区别和定义方式
white_ice的博客
09-23 3812
区别：java中：定义数组必须指定长度，而且长度确定下来之后无法改变。    js中：js中的数组和java中的集合差不多，长度是可变的，也没有强制要求必须定义长度。 定义方法：java： int a[] = new int[3];//定义一个新数组，在内存中分配了3*4个字节 //快速初始化数组的两种方式 int b[] = {1,2,3}; int c[] =
js数组和java数组的区别
前端kk的博客
04-06 415
js数组和java数组的区别
java 解析js数组对象_JavaScript 浅析数组对象与类数组对象
weixin_39531688的博客
02-25 233
数组(Array对象)数组就是一组数据.在JavaScript中没有数组这种数据类型.数组时对象创建的.键(下标): 用于区分数组中不同数值的标志就是键,初始键为0.以数字作为下标的键,这种数组称之为索引数组.以字符串作为下标的键,这种数组称之为关联数组注意: 在JavaScript中只有索引数组,y没有关联数组,必须是从0开始连续的索引数组!值:每个键对应的数据就是值.键值对:键+值 就是键值对...
java 解析js数组对象_详解JavaScript对象和数组
weixin_29480659的博客
02-25 494
许多高级编程语言都是面向对象的，比如C++、C#和Java等高级程序设计语言，那么一种面向对象语言有哪些基本要求呢？下面我们就通宿地说一下面向对象的一些知识。一种面向对象语言需要向开发者提供四种基本能力：(1)封装：把相关的信息(无论数据或方法)存储在对象中的能力(2)聚集：把一个对象存储在另一个对象内的能力(3)继承：由另一个类(或多个类)得来类的属性和方法的能力(4)多态：编写能以多种方法运行...
java中接受js数组
yztezhl的专栏
05-22 2434
定义一个js的数组 var arr = [                     ["1"],                     ["2"]                 ]; 经过java引擎解析后，得到的对象是sun.org......NativeArray 在我的eclipse中找不到这个类。也就没办法直接转换成java数组对象了。 现在换成在js中使用java的
【JavaScrpt】超详细的js数组方法（总结）
德仔
09-23 360
在平时的开发中我们经常会用的数组的内置方法，也是面试最常问到的东西。数组是js中最常用到的数据集合，其内置的方法有很多，熟练掌握这些方法，可以有效的提高我们的工作效率，同时对我们的代码质量也是有很大影响。
java解析js数组_[Java教程]关于JS中数组的分析操作
weixin_34345599的博客
02-21 156
[Java教程]关于JS中数组的分析操作0 2017-07-25 00:00:20JS数组的基础操作代码：数组的三种定义var arr1 = new Array();var arr3 = Array(1,2,3.5,4,'5',false);var arr2 = [1,2,3,4,'5',"aa",true];var i;var arr4 = [];arr4[3] = 12;arr4...
java解析js数组_js接收并转化Java中的数组对象
05-27
要在Java中解析JavaScript数组，可以使用Java中的Nashorn引擎来执行JavaScript代码，然后将结果转换为Java中的数组对象。 以下是一个示例代码，演示如何在Java中解析JavaScript中的数组： ```java import javax....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值