wespten
wespten

深入学习java源码之Arrays.asList()与Arrays.stream()

深入学习java源码之Arrays.asList()与Arrays.stream()

RandomAccess标记接口

标记接口，Marker interface，它们是一类没有定义任何接口方法的接口，表现为一个空接口 
没有接口方法意味着实现该接口的类无需实现任何接口方法，仅仅作为一种标记，以供其他方法判断 
作用就是当某个类实现这个接口后即拥有了这个接口的功能，Java 虚拟机在运行时会识别到它 
标记接口是Java的语言特性 
在计算机科学中，随机访问（RandomAccess）是从大量的可寻址元素的数据中访问任何元素大致和访问其他元素一样简洁有效，不管多少元素在这个集合中。与随机访问相反的是顺序访问（SequenceAccess）

RandomAccess 就是一个标记接口，用于标明实现该接口的List支持快速随机访问，主要目的是使算法能够在随机和顺序访问的List中性能更加高效（在Collections二分查找时）。

JDK中说的很清楚，在对List特别是Huge size的List的遍历算法中，要尽量来判断是属于RandomAccess(如：ArrayList)还是SequenceAccess(如：LinkedList) 

RandomAccess是一个空接口，而空接口的作用一般是起到一个标识的作用。 
通俗点讲，就是判断一个list是否实现了RandomAcess接口，如果实现了，采用简单的for循环进行访问速度比较快。 
如果未实现RandomAcess接口，则采用iterator循环访问速度比较快。 
判断使用instanceof
Collections的binarySearch方法：

public static  int binarySearch(List> list, T key) {
    if (list instanceof RandomAccess || list.size()

在进行二分查找时，首先判断list是否实现了RandomAccess，然后选择执行最优算法。 
如果集合类是RandomAccess的实现，则尽量用for(int i = 0; i < size; i++) 即for循环来遍历，而不是用Iterator 
迭代器来进行迭代。

 

Serialization序列化

序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

三种情况：

1. 将对象存储再硬盘上。

2. 将对象通过网络传输。

3. 通过RMI远程调用等方式传输对象的时候。

在这三种情况下，是需要进行序列化然后传输的。

对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。

然而在实际开发过程中，我们常常会遇到这样的问题，这个类的有些属性需要序列化，而其他属性不需要被序列化，打个比方，如果一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，这些信息对应的变量就可以加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

总之，java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
 
/**
 * @description 使用transient关键字不序列化某个变量
 *        注意读取的时候，读取数据的顺序一定要和存放数据的顺序保持一致
 *        
 * @author Alexia
 * @date  2013-10-15
 */
public class TransientTest {
 
    public static void main(String[] args) {
 
        User user = new User();
        user.setUsername("Alexia");
        user.setPasswd("123456");
 
        System.out.println("read before Serializable: ");
        System.out.println("username: " + user.getUsername());
        System.err.println("password: " + user.getPasswd());
 
        try {
            ObjectOutputStream os = new ObjectOutputStream(
                    new FileOutputStream("C:/user.txt"));
            os.writeObject(user); // 将User对象写进文件
            os.flush();
            os.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            ObjectInputStream is = new ObjectInputStream(new FileInputStream(
                    "C:/user.txt"));
            user = (User) is.readObject(); // 从流中读取User的数据
            is.close();
 
            System.out.println("\nread after Serializable: ");
            System.out.println("username: " + user.getUsername());
            System.err.println("password: " + user.getPasswd());
 
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
 
class User implements Serializable {
    private static final long serialVersionUID = 8294180014912103005L;  
 
    private String username;
    private transient String passwd;
 
    public String getUsername() {
        return username;
    }
 
    public void setUsername(String username) {
        this.username = username;
    }
 
    public String getPasswd() {
        return passwd;
    }
 
    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }
 
}

输出为：

read before Serializable: 
username: Alexia
password: 123456
 
read after Serializable: 
username: Alexia
password: null

密码字段为null，说明反序列化时根本没有从文件中获取到信息。

transient使用小结

1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。

2）transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。

3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

第三点可能有些人很迷惑，因为发现在User类中的username字段前加上static关键字后，程序运行结果依然不变，即static类型的username也读出来为“Alexia”了，这不与第三点说的矛盾吗？实际上是这样的：第三点确实没错（一个静态变量不管是否被transient修饰，均不能被序列化），反序列化后类中static型变量username的值为当前JVM中对应static变量的值，这个值是JVM中的不是反序列化得出的

我们知道在Java中，对象的序列化可以通过实现两种接口来实现，若实现的是Serializable接口，则所有的序列化将会自动进行，若实现的是Externalizable接口，则没有任何东西可以自动序列化，需要在writeExternal方法中进行手工指定所要序列化的变量，这与是否被transient修饰无关。因此第二个例子输出的是变量content初始化的内容，而不是null。

public class ExternalizableTest implements Externalizable {
 
    private transient String content = "是的，我将会被序列化，不管我是否被transient关键字修饰";
 
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(content);
    }
 
    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        content = (String) in.readObject();
    }
 
    public static void main(String[] args) throws Exception {
 
        ExternalizableTest et = new ExternalizableTest();
        ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
                new File("test")));
        out.writeObject(et);
 
        ObjectInput in = new ObjectInputStream(new FileInputStream(new File(
                "test")));
        et = (ExternalizableTest) in.readObject();
        System.out.println(et.content);
 
        out.close();
        in.close();
    }
}

 

 

 

Modifier and Type Method and Description
static List asList(T... a)

返回由指定数组支持的固定大小的列表。
static boolean deepEquals(Object[] a1, Object[] a2)

如果两个指定的数组彼此 深度相等 ，则返回 true 。
static int deepHashCode(Object[] a)

根据指定数组的“深度内容”返回哈希码。
static String deepToString(Object[] a)

返回指定数组的“深度内容”的字符串表示形式。
static boolean equals(boolean[] a, boolean[] a2)

如果两个指定的布尔数组彼此 相等 ，则返回 true 。
static boolean equals(byte[] a, byte[] a2)

如果两个指定的字节数组彼此 相等 ，则返回 true 。
static boolean equals(char[] a, char[] a2)

如果两个指定的字符数组彼此 相等 ，则返回 true 。
static boolean equals(double[] a, double[] a2)

如果两个指定的双精度数组彼此 相等 ，则返回 true 。
static boolean equals(float[] a, float[] a2)

如果两个指定的浮动数组彼此 相等 ，则返回 true 。
static boolean equals(int[] a, int[] a2)

如果两个指定的int数组彼此 相等 ，则返回 true 。
static boolean equals(long[] a, long[] a2)

如果两个指定的longs数组彼此 相等 ，则返回 true 。
static boolean equals(Object[] a, Object[] a2)

如果两个指定的对象数组彼此 相等 ，则返回 true 。
static boolean equals(short[] a, short[] a2)

如果两个指定的短裤阵列彼此 相等 ，则返回 true 。
static int hashCode(boolean[] a)

根据指定数组的内容返回哈希码。
static int hashCode(byte[] a)

根据指定数组的内容返回哈希码。
static int hashCode(char[] a)

根据指定数组的内容返回哈希码。
static int hashCode(double[] a)

根据指定数组的内容返回哈希码。
static int hashCode(float[] a)

根据指定数组的内容返回哈希码。
static int hashCode(int[] a)

根据指定数组的内容返回哈希码。
static int hashCode(long[] a)

根据指定数组的内容返回哈希码。
static int hashCode(Object[] a)

根据指定数组的内容返回哈希码。
static int hashCode(short[] a)

根据指定数组的内容返回哈希码。
static void parallelSetAll(double[] array, IntToDoubleFunction generator)

使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
static void parallelSetAll(int[] array, IntUnaryOperator generator)

使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
static void parallelSetAll(long[] array, IntToLongFunction generator)

使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
static void parallelSetAll(T[] array, IntFunction generator)

使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素。
static void setAll(double[] array, IntToDoubleFunction generator)

使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
static void setAll(int[] array, IntUnaryOperator generator)

使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
static void setAll(long[] array, IntToLongFunction generator)

使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
static void setAll(T[] array, IntFunction generator)

使用提供的生成函数来计算每个元素，设置指定数组的所有元素。
static Spliterator.OfDouble spliterator(double[] array)

返回Spliterator.OfDouble覆盖所有指定数组。
static Spliterator.OfDouble spliterator(double[] array, int startInclusive, int endExclusive)

返回Spliterator.OfDouble覆盖指定数组的指定范围内。
static Spliterator.OfInt spliterator(int[] array)

返回Spliterator.OfInt覆盖所有指定数组。
static Spliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive)

返回Spliterator.OfInt覆盖指定数组的指定范围内。
static Spliterator.OfLong spliterator(long[] array)

返回Spliterator.OfLong覆盖所有指定数组。
static Spliterator.OfLong spliterator(long[] array, int startInclusive, int endExclusive)

返回Spliterator.OfLong覆盖指定数组的指定范围内。
static Spliterator spliterator(T[] array)

返回Spliterator覆盖所有指定数组。
static Spliterator spliterator(T[] array, int startInclusive, int endExclusive)

返回Spliterator覆盖指定数组的指定范围内。
static DoubleStream stream(double[] array)

返回顺序DoubleStream与指定的数组作为源。
static DoubleStream stream(double[] array, int startInclusive, int endExclusive)

返回顺序DoubleStream与指定的数组作为源的指定范围。
static IntStream stream(int[] array)

返回顺序IntStream与指定的数组作为源。
static IntStream stream(int[] array, int startInclusive, int endExclusive)

返回顺序IntStream与指定的数组作为源的指定范围。
static LongStream stream(long[] array)

返回顺序LongStream与指定的数组作为源。
static LongStream stream(long[] array, int startInclusive, int endExclusive)

返回顺序LongStream与指定的数组作为源的指定范围。
static Stream stream(T[] array)

返回顺序Stream与指定的数组作为源。
static Stream stream(T[] array, int startInclusive, int endExclusive)

返回顺序Stream与指定的数组作为源的指定范围。
static String toString(boolean[] a)

返回指定数组的内容的字符串表示形式。
static String toString(byte[] a)

返回指定数组的内容的字符串表示形式。
static String toString(char[] a)

返回指定数组的内容的字符串表示形式。
static String toString(double[] a)

返回指定数组的内容的字符串表示形式。
static String toString(float[] a)

返回指定数组的内容的字符串表示形式。
static String toString(int[] a)

返回指定数组的内容的字符串表示形式。
static String toString(long[] a)

返回指定数组的内容的字符串表示形式。
static String toString(Object[] a)

返回指定数组的内容的字符串表示形式。
static String toString(short[] a)

返回指定数组的内容的字符串表示形式。

java源码

package java.util;

import java.lang.reflect.Array;
import java.util.concurrent.ForkJoinPool;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.DoubleBinaryOperator;
import java.util.function.IntBinaryOperator;
import java.util.function.IntFunction;
import java.util.function.IntToDoubleFunction;
import java.util.function.IntToLongFunction;
import java.util.function.IntUnaryOperator;
import java.util.function.LongBinaryOperator;
import java.util.function.UnaryOperator;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class Arrays {

    private static final int MIN_ARRAY_SORT_GRAN = 1 << 13;

    // Suppresses default constructor, ensuring non-instantiability.
    private Arrays() {}

    static final class NaturalOrder implements Comparator {
        @SuppressWarnings("unchecked")
        public int compare(Object first, Object second) {
            return ((Comparable)first).compareTo(second);
        }
        static final NaturalOrder INSTANCE = new NaturalOrder();
    }

    private static void rangeCheck(int arrayLength, int fromIndex, int toIndex) {
        if (fromIndex > toIndex) {
            throw new IllegalArgumentException(
                    "fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")");
        }
        if (fromIndex < 0) {
            throw new ArrayIndexOutOfBoundsException(fromIndex);
        }
        if (toIndex > arrayLength) {
            throw new ArrayIndexOutOfBoundsException(toIndex);
        }
    }

    @SafeVarargs
    @SuppressWarnings("varargs")
    public static  List asList(T... a) {
        return new ArrayList<>(a);
    }
	
    /**
     * @serial include
     */
    private static class ArrayList extends AbstractList
        implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }

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

        @Override
        public Object[] toArray() {
            return a.clone();
        }

        @Override
        @SuppressWarnings("unchecked")
        public  T[] toArray(T[] a) {
            int size = size();
            if (a.length < size)
                return Arrays.copyOf(this.a, size,
                                     (Class) a.getClass());
            System.arraycopy(this.a, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }

        @Override
        public E get(int index) {
            return a[index];
        }

        @Override
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }

        @Override
        public int indexOf(Object o) {
            E[] a = this.a;
            if (o == null) {
                for (int i = 0; i < a.length; i++)
                    if (a[i] == null)
                        return i;
            } else {
                for (int i = 0; i < a.length; i++)
                    if (o.equals(a[i]))
                        return i;
            }
            return -1;
        }

        @Override
        public boolean contains(Object o) {
            return indexOf(o) != -1;
        }

        @Override
        public Spliterator spliterator() {
            return Spliterators.spliterator(a, Spliterator.ORDERED);
        }

        @Override
        public void forEach(Consumer action) {
            Objects.requireNonNull(action);
            for (E e : a) {
                action.accept(e);
            }
        }

        @Override
        public void replaceAll(UnaryOperator operator) {
            Objects.requireNonNull(operator);
            E[] a = this.a;
            for (int i = 0; i < a.length; i++) {
                a[i] = operator.apply(a[i]);
            }
        }

        @Override
        public void sort(Comparator c) {
            Arrays.sort(a, c);
        }
    }
	
    public static int hashCode(long a[]) {
        if (a == null)
            return 0;

        int result = 1;
        for (long element : a) {
            int elementHash = (int)(element ^ (element >>> 32));
            result = 31 * result + elementHash;
        }

        return result;
    }
	
    public static int hashCode(int a[]) {
        if (a == null)
            return 0;

        int result = 1;
        for (int element : a)
            result = 31 * result + element;

        return result;
    }	
	
    public static int hashCode(short a[]) {
        if (a == null)
            return 0;

        int result = 1;
        for (short element : a)
            result = 31 * result + element;

        return result;
    }	
	
    public static int hashCode(char a[]) {
        if (a == null)
            return 0;

        int result = 1;
        for (char element : a)
            result = 31 * result + element;

        return result;
    }
	
    public static int hashCode(byte a[]) {
        if (a == null)
            return 0;

        int result = 1;
        for (byte element : a)
            result = 31 * result + element;

        return result;
    }	
	
    public static int hashCode(boolean a[]) {
        if (a == null)
            return 0;

        int result = 1;
        for (boolean element : a)
            result = 31 * result + (element ? 1231 : 1237);

        return result;
    }	
	
    public static int hashCode(float a[]) {
        if (a == null)
            return 0;

        int result = 1;
        for (float element : a)
            result = 31 * result + Float.floatToIntBits(element);

        return result;
    }

    public static int hashCode(double a[]) {
        if (a == null)
            return 0;

        int result = 1;
        for (double element : a) {
            long bits = Double.doubleToLongBits(element);
            result = 31 * result + (int)(bits ^ (bits >>> 32));
        }
        return result;
    }

    public static int hashCode(Object a[]) {
        if (a == null)
            return 0;

        int result = 1;

        for (Object element : a)
            result = 31 * result + (element == null ? 0 : element.hashCode());

        return result;
    }

    public static int deepHashCode(Object a[]) {
        if (a == null)
            return 0;

        int result = 1;

        for (Object element : a) {
            int elementHash = 0;
            if (element instanceof Object[])
                elementHash = deepHashCode((Object[]) element);
            else if (element instanceof byte[])
                elementHash = hashCode((byte[]) element);
            else if (element instanceof short[])
                elementHash = hashCode((short[]) element);
            else if (element instanceof int[])
                elementHash = hashCode((int[]) element);
            else if (element instanceof long[])
                elementHash = hashCode((long[]) element);
            else if (element instanceof char[])
                elementHash = hashCode((char[]) element);
            else if (element instanceof float[])
                elementHash = hashCode((float[]) element);
            else if (element instanceof double[])
                elementHash = hashCode((double[]) element);
            else if (element instanceof boolean[])
                elementHash = hashCode((boolean[]) element);
            else if (element != null)
                elementHash = element.hashCode();

            result = 31 * result + elementHash;
        }

        return result;
    }

    public static boolean deepEquals(Object[] a1, Object[] a2) {
        if (a1 == a2)
            return true;
        if (a1 == null || a2==null)
            return false;
        int length = a1.length;
        if (a2.length != length)
            return false;

        for (int i = 0; i < length; i++) {
            Object e1 = a1[i];
            Object e2 = a2[i];

            if (e1 == e2)
                continue;
            if (e1 == null)
                return false;

            // Figure out whether the two elements are equal
            boolean eq = deepEquals0(e1, e2);

            if (!eq)
                return false;
        }
        return true;
    }

    static boolean deepEquals0(Object e1, Object e2) {
        assert e1 != null;
        boolean eq;
        if (e1 instanceof Object[] && e2 instanceof Object[])
            eq = deepEquals ((Object[]) e1, (Object[]) e2);
        else if (e1 instanceof byte[] && e2 instanceof byte[])
            eq = equals((byte[]) e1, (byte[]) e2);
        else if (e1 instanceof short[] && e2 instanceof short[])
            eq = equals((short[]) e1, (short[]) e2);
        else if (e1 instanceof int[] && e2 instanceof int[])
            eq = equals((int[]) e1, (int[]) e2);
        else if (e1 instanceof long[] && e2 instanceof long[])
            eq = equals((long[]) e1, (long[]) e2);
        else if (e1 instanceof char[] && e2 instanceof char[])
            eq = equals((char[]) e1, (char[]) e2);
        else if (e1 instanceof float[] && e2 instanceof float[])
            eq = equals((float[]) e1, (float[]) e2);
        else if (e1 instanceof double[] && e2 instanceof double[])
            eq = equals((double[]) e1, (double[]) e2);
        else if (e1 instanceof boolean[] && e2 instanceof boolean[])
            eq = equals((boolean[]) e1, (boolean[]) e2);
        else
            eq = e1.equals(e2);
        return eq;
    }
	
    public static String toString(long[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }	
	
    public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }

    public static String toString(short[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }

    public static String toString(char[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }

    public static String toString(byte[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }
	
    public static String toString(boolean[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }
	
    public static String toString(float[] a) {
        if (a == null)
            return "null";

        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }	

    public static String toString(double[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }

    public static String toString(Object[] a) {
        if (a == null)
            return "null";

        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(String.valueOf(a[i]));
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }

    public static String deepToString(Object[] a) {
        if (a == null)
            return "null";

        int bufLen = 20 * a.length;
        if (a.length != 0 && bufLen <= 0)
            bufLen = Integer.MAX_VALUE;
        StringBuilder buf = new StringBuilder(bufLen);
        deepToString(a, buf, new HashSet());
        return buf.toString();
    }

    private static void deepToString(Object[] a, StringBuilder buf,
                                     Set dejaVu) {
        if (a == null) {
            buf.append("null");
            return;
        }
        int iMax = a.length - 1;
        if (iMax == -1) {
            buf.append("[]");
            return;
        }

        dejaVu.add(a);
        buf.append('[');
        for (int i = 0; ; i++) {

            Object element = a[i];
            if (element == null) {
                buf.append("null");
            } else {
                Class eClass = element.getClass();

                if (eClass.isArray()) {
                    if (eClass == byte[].class)
                        buf.append(toString((byte[]) element));
                    else if (eClass == short[].class)
                        buf.append(toString((short[]) element));
                    else if (eClass == int[].class)
                        buf.append(toString((int[]) element));
                    else if (eClass == long[].class)
                        buf.append(toString((long[]) element));
                    else if (eClass == char[].class)
                        buf.append(toString((char[]) element));
                    else if (eClass == float[].class)
                        buf.append(toString((float[]) element));
                    else if (eClass == double[].class)
                        buf.append(toString((double[]) element));
                    else if (eClass == boolean[].class)
                        buf.append(toString((boolean[]) element));
                    else { // element is an array of object references
                        if (dejaVu.contains(element))
                            buf.append("[...]");
                        else
                            deepToString((Object[])element, buf, dejaVu);
                    }
                } else {  // element is non-null and not an array
                    buf.append(element.toString());
                }
            }
            if (i == iMax)
                break;
            buf.append(", ");
        }
        buf.append(']');
        dejaVu.remove(a);
    }

    public static  void setAll(T[] array, IntFunction generator) {
        Objects.requireNonNull(generator);
        for (int i = 0; i < array.length; i++)
            array[i] = generator.apply(i);
    }

    public static  void parallelSetAll(T[] array, IntFunction generator) {
        Objects.requireNonNull(generator);
        IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.apply(i); });
    }

    public static void setAll(int[] array, IntUnaryOperator generator) {
        Objects.requireNonNull(generator);
        for (int i = 0; i < array.length; i++)
            array[i] = generator.applyAsInt(i);
    }

    public static void parallelSetAll(int[] array, IntUnaryOperator generator) {
        Objects.requireNonNull(generator);
        IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.applyAsInt(i); });
    }

    public static void setAll(long[] array, IntToLongFunction generator) {
        Objects.requireNonNull(generator);
        for (int i = 0; i < array.length; i++)
            array[i] = generator.applyAsLong(i);
    }

    public static void parallelSetAll(long[] array, IntToLongFunction generator) {
        Objects.requireNonNull(generator);
        IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.applyAsLong(i); });
    }

    public static void setAll(double[] array, IntToDoubleFunction generator) {
        Objects.requireNonNull(generator);
        for (int i = 0; i < array.length; i++)
            array[i] = generator.applyAsDouble(i);
    }

    public static void parallelSetAll(double[] array, IntToDoubleFunction generator) {
        Objects.requireNonNull(generator);
        IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.applyAsDouble(i); });
    }

    public static  Spliterator spliterator(T[] array) {
        return Spliterators.spliterator(array,
                                        Spliterator.ORDERED | Spliterator.IMMUTABLE);
    }

    public static  Spliterator spliterator(T[] array, int startInclusive, int endExclusive) {
        return Spliterators.spliterator(array, startInclusive, endExclusive,
                                        Spliterator.ORDERED | Spliterator.IMMUTABLE);
    }

    public static Spliterator.OfInt spliterator(int[] array) {
        return Spliterators.spliterator(array,
                                        Spliterator.ORDERED | Spliterator.IMMUTABLE);
    }

    public static Spliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive) {
        return Spliterators.spliterator(array, startInclusive, endExclusive,
                                        Spliterator.ORDERED | Spliterator.IMMUTABLE);
    }

    public static Spliterator.OfLong spliterator(long[] array) {
        return Spliterators.spliterator(array,
                                        Spliterator.ORDERED | Spliterator.IMMUTABLE);
    }

    public static Spliterator.OfLong spliterator(long[] array, int startInclusive, int endExclusive) {
        return Spliterators.spliterator(array, startInclusive, endExclusive,
                                        Spliterator.ORDERED | Spliterator.IMMUTABLE);
    }

    public static Spliterator.OfDouble spliterator(double[] array) {
        return Spliterators.spliterator(array,
                                        Spliterator.ORDERED | Spliterator.IMMUTABLE);
    }

    public static Spliterator.OfDouble spliterator(double[] array, int startInclusive, int endExclusive) {
        return Spliterators.spliterator(array, startInclusive, endExclusive,
                                        Spliterator.ORDERED | Spliterator.IMMUTABLE);
    }

    public static  Stream stream(T[] array) {
        return stream(array, 0, array.length);
    }

    public static  Stream stream(T[] array, int startInclusive, int endExclusive) {
        return StreamSupport.stream(spliterator(array, startInclusive, endExclusive), false);
    }

    public static IntStream stream(int[] array) {
        return stream(array, 0, array.length);
    }

    public static IntStream stream(int[] array, int startInclusive, int endExclusive) {
        return StreamSupport.intStream(spliterator(array, startInclusive, endExclusive), false);
    }

    public static LongStream stream(long[] array) {
        return stream(array, 0, array.length);
    }

    public static LongStream stream(long[] array, int startInclusive, int endExclusive) {
        return StreamSupport.longStream(spliterator(array, startInclusive, endExclusive), false);
    }

    public static DoubleStream stream(double[] array) {
        return stream(array, 0, array.length);
    }
    public static DoubleStream stream(double[] array, int startInclusive, int endExclusive) {
        return StreamSupport.doubleStream(spliterator(array, startInclusive, endExclusive), false);
    }
}
	
 
  
package java.util;

public interface RandomAccess {
}

 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Java源码)

        

            

                
    
                    
  • app反编译工具及使用
                        じ 耐人
网络安全
                        
    apktool——可以反编译软件的布局文件、图片等资源，方便大家学习一些很好的布局；dex2jar——将apk反编译成java源码（classes.dex转化成jar文件）；jd-gui——查看APK中classes.dex转化成出的jar文件，即源码文件。apktool使用方法解包：java-jarapktool_2.4.1.jarddemo.apk-odemo//其中d后面是要反编译的apk文
    
                    
    • 
                    
  • 【乐吾乐大屏可视化组态编辑器】API接口文档（pgsql）
                        乐吾乐科技
2D可视化组态编辑器编辑器前端流程图开源交互数据可视化
                        
    API接口文档（pgsql）在线使用：https://v.le5le.com/采用前后端分离架构，乐吾乐后端服务提供一整套完整的web组态编辑器的所有数据接口，包含2D/3D图纸接口服务、文件接口服务和用户接口服务等，安装包版本提供后端可执行程序文件，后端源码版提供Java源码。用户也可以自行按照接口文档去实现部分必要的接口，参考接口文档如下：全局规则默认：所有接口返回通过是否包含error字段来
    
                    
    • 
                    
  • java计算机毕业设计音乐微信小程序（开题+程序+论文）
                        世迁科技
java课程设计微信小程序
                        
    本系统（程序+源码）带文档lw万字以上文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容研究背景随着移动互联网的飞速发展，微信小程序作为一种轻量级的应用形态，凭借其无需下载、即用即走的特性，迅速渗透至用户生活的方方面面。音乐作为人们日常生活中不可或缺的精神食粮，其获取与分享方式也在不断进化。传统音乐应用虽功能丰富，但占用手机内存大、启动速度慢等问题日益凸显。因此，开发一款
    
                    
    • 
                    
  • 计算机毕设ssm房屋出租管理系统w1305（开题+源码）
                        java毕设程序源码王哥
课程设计
                        
    本项目包含程序+源码+数据库+LW+调试部署环境，文末可获取一份本项目的java源码和数据库参考。开题报告研究背景：随着城市化进程的加快和人口的不断增长，房屋出租管理成为一个重要的问题。传统的房屋出租管理方式存在诸多问题，如信息不对称、租金纠纷、合同管理困难等。因此，建立一套高效、便捷的房屋出租管理系统势在必行。研究意义：房屋出租管理系统的建立具有重要的社会和经济意义。首先，它可以提高房东和租户之
    
                    
    • 
                    
  • java源码学习-Mybatis(2)与数据库建立连接
                        子波zibo
源码学习java基础mybatisjavajdbc
                        
    Mybatis与数据库建立连接jdbc执行流程图Mybatis初始化Hikari连接池的启动Mybatis获取数据库连接后记前文:Mybatis加载mapper流程由于mybatis是在jdbc的基础上进行封装的,所以jdbc执行流程获取连接->创建statements->resultSet这些步骤mybatis都是存在的,本篇学习一下Mybatis获取Connection的步骤jdbc执行流程图
    
                    
    • 
                    
  • 【附源码】java手机进存销系统（ssm毕业设计+maven+vue+计算机专业）
                        阿联毕设程序
java课程设计maven
                        
    本系统（程序+源码）带文档lw万字以上文末可领取本课题的JAVA源码参考系统程序文件列表系统的选题背景和意义选题背景：在当今的信息化时代，智能手机已成为人们日常生活中不可或缺的工具。随着科技的进步和移动互联网的发展，手机的功能不再局限于通讯，而是扩展到了各个领域，其中就包括进存销系统的管理。传统的进存销系统多依赖于电脑和专业的管理软件，需要固定的操作环境和专业人员进行数据输入和管理。然而，随着智能
    
                    
    • 
                    
  • Java源码解读-数据容器都是如何实现同步的
                        问道飞鱼
Java开发Java源码解读数据容器同步机制
                        
    用Java的同学可能在自己使用或者面试的时候经常遇到这么一个问题，哪些数据结构或者容器是同步的，是怎么实现的同步？其实很多的数据同步原理都比较简单，我把目前知道的数据容器的同步方式稍微梳理了一下1.线程安全容器StringBuffer(太明显，synchronized关键字）@OverridepublicsynchronizedStringBufferappend(Stringstr){toStr
    
                    
    • 
                    
  • Java 代码 编译和执行过程
                        萧关逢候骑11

                        
    这篇文章讲述的很清楚，在此记录一下，为了以后复习使用。https://blog.csdn.net/mccand1234/article/details/52013918文章目录流程图Java源码编译机制类加载机制类执行机制实例流程图Java代码编译是由Java源码编译器来完成，Java代码编译流程图如下所示：Java字节码（class文件）的执行是由JVM执行引擎来完成，Java字节码的执行流程图
    
                    
    • 
                    
  • Java源码学习之高并发编程基础——AQS源码剖析之阻塞队列（下）
                        永往不庭
java学习后端性能优化
                        
    1.前言&目录前言：在上一篇文章AQS源码剖析之阻塞队列（上）中介绍了以独占锁模式下AQS的基本原理，AQS仅仅起到了一个“维持线程等待秩序”的作用，那么本篇文章继续讲解共享锁模式下的特点。AQS不操纵锁的获取或者释放，仅仅提供一个由双向链表组成的队列，让抢不到锁的线程进入队列排队并阻塞起来、持有锁的线程释放锁后“通知”（即从阻塞态中唤醒）排名最靠前的有效（非CANCELLED状态）节点去重新竞争
    
                    
    • 
                    
  • 基于ssm+vue废品回收管理系统设计与实现【开题+程序+论文】
                        sheji404
vue.js前端javascript
                        
    本系统（程序+源码）带文档lw万字以上文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容研究背景随着社会的快速发展和人们生活水平的不断提升，垃圾产生量急剧增加，垃圾分类与回收已成为环境保护和可持续发展的关键议题。然而，当前废品回收领域仍面临着诸多挑战，如回收效率低、分类不准确、居民参与度不高等问题。传统的人工分类方式不仅耗时费力，且难以保证分类的准确性，严重制约了废品回收
    
                    
    • 
                    
  • 工厂模式 vs 策略模式：Java设计模式详细对比
                        勤劳兔码农
策略模式java设计模式
                        
    工厂模式vs策略模式：Java设计模式详细对比设计模式是软件开发中提高系统灵活性、可维护性和可扩展性的有效方法。工厂模式和策略模式是两种常用的设计模式，它们各自有不同的应用场景和优势。本文将详细对比工厂模式和策略模式，通过具体的Java源码示例来帮助理解它们的使用场景和实现方法。1.工厂模式概述1.1工厂模式的定义工厂模式（FactoryPattern）是一种创建型设计模式，旨在定义一个用于创建对
    
                    
    • 
                    
  • java源码浅析之dubbo
                        DaHuangXiao
随笔java
                        
    前言最近在看RPC框架，选择先看dubbo，再看netty，最后手写一个RPC的学习路线，结合雷神关于dubbo的讲解，对源码流程进行一个简单的记录原理所谓RPC就是远程服务调用的意思，那么dubbo怎么完成远程调用的呢？原理图如下[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9fEwo2Az-1623312993257)(java源码解析之dubbo.assets
    
                    
    • 
                    
  • 基于BS架构的停车场管理系统(源码+开题)
                        杰简程序毕设
架构
                        
    本系统（程序+源码）带文档lw万字以上文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容研究背景随着城市化进程的加速，车辆数量不断增加，停车难问题日益凸显。传统的停车场管理系统已难以满足现代停车场高效、便捷、智能的管理需求。基于BS架构的停车场管理系统，以其跨平台、易维护、可扩展的优势，逐渐受到业界的关注。该系统不仅能实时更新停车位信息，提供车位预约、充电桩预约等功能，还
    
                    
    • 
                    
  • 基于EE的社区订餐系统(源码+开题)
                        杰简程序毕设
数据库前端大数据
                        
    本系统（程序+源码）带文档lw万字以上文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容研究背景随着信息技术的快速发展和人们生活节奏的加快，传统的社区订餐方式已经无法满足现代都市人的需求。传统的订餐方式往往存在着信息不对称、效率低下、服务体验不佳等问题。因此，开发一款基于互联网的社区订餐系统变得尤为重要。该系统通过集成现代互联网技术，如大数据分析、云计算等，旨在提升社区订
    
                    
    • 
                    
  • 基于bs架构的高校在线考试系统(源码+开题)
                        杰简程序毕设
架构
                        
    本系统（程序+源码）带文档lw万字以上文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容研究背景随着信息技术的不断发展和普及，高校教育教学方式也在逐步向数字化、网络化转变。传统的考试方式已经难以满足现代教育的需求，尤其是在疫情期间，线上教学和考试成为了主流。因此，开发一款基于BS架构的高校在线考试系统，不仅能够满足学生的在线学习需求，提高考试效率，同时也能够确保考试的公正
    
                    
    • 
                    
  • 基于B_S的妇幼健康管理系统(源码+开题)
                        杰简程序毕设
java数据库大数据
                        
    本系统（程序+源码）带文档lw万字以上文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容研究背景随着社会的快速发展和医疗技术的不断进步，妇幼健康管理在公共卫生领域的重要性日益凸显。当前，我国正面临着人口结构转变、生育政策调整等多重挑战，对妇幼健康服务的需求也在不断增加。传统的妇幼健康管理模式已难以满足现代社会的需求，亟需一种更加高效、便捷、智能化的管理系统来提升服务质量。
    
                    
    • 
                    
  • java/jsp/ssm汉服文化宣传网站【2024年毕设】
                        扬基程序
java课程设计开发语言
                        
    本系统带文档lw万字以上文末可领取本课题的JAVA源码参考开发环境开发语言：Java框架：ssm技术：ssm+jspJDK版本：JDK1.8服务器：tomcat7数据库：mysql5.7或8.0数据库工具：Navicat11开发软件：eclipse/myeclipse/ideaMaven包：Maven3.3.9浏览器：建议谷歌浏览器或edge功能模块系统界面2023-2024年成品除了以上作品下面
    
                    
    • 
                    
  • java/jsp/ssm影视论坛交流网站【2024年毕设】
                        灵军程序设计
java课程设计开发语言
                        
    本系统带文档lw万字以上文末可领取本课题的JAVA源码参考开发环境开发语言：Java框架：ssm技术：ssm+jspJDK版本：JDK1.8服务器：tomcat7数据库：mysql5.7或8.0数据库工具：Navicat11开发软件：eclipse/myeclipse/ideaMaven包：Maven3.3.9浏览器：建议谷歌浏览器或edge功能模块系统界面2023-2024年成品除了以上作品下面
    
                    
    • 
                    
  • springboot/java/php/node/python微信商城小程序【计算机毕设】
                        php-毕业源码设计
javaspringbootphp
                        
    本系统（程序+源码）带文档lw万字以上文末可领取本课题的JAVA源码参考系统程序文件列表系统的选题背景和意义选题背景：随着移动互联网技术的飞速发展，智能手机的普及率日益增高，人们的生活方式和消费习惯也发生了翻天覆地的变化。微信作为一款集社交、支付、信息获取等多功能于一体的超级应用程序，其用户数量已突破亿级大关，成为人们日常生活中不可或缺的一部分。在这样的背景下，微信商城小程序应运而生，它依托微信庞
    
                    
    • 
                    
  • springboot/java/php/node/python小程序任务调度管理信息系统【计算机毕设】
                        php-毕业源码设计
javaspringbootphp
                        
    本系统（程序+源码）带文档lw万字以上文末可领取本课题的JAVA源码参考系统程序文件列表系统的选题背景和意义选题背景：随着移动互联网技术的飞速发展，小程序作为一种新型的应用形式，因其无需下载安装、使用即走的便捷性，越来越多地融入人们的日常生活和工作中。企业和组织也开始利用小程序来优化业务流程、提高工作效率。在此背景下，任务调度管理信息系统作为一种重要的企业资源规划工具，其作用在于协调各类资源、安排
    
                    
    • 
                    
  • springboot/java/php/node/python物业管理小程序【计算机毕设】
                        php-毕业源码设计
javaspringbootphp
                        
    本系统（程序+源码）带文档lw万字以上文末可领取本课题的JAVA源码参考系统程序文件列表系统的选题背景和意义选题背景：随着城市化进程的加速和居民生活水平的提高，物业管理作为居住社区的重要组成部分，其服务质量直接影响到居民的日常生活满意度。传统的物业管理方式多依赖人工操作，不仅效率较低，而且难以满足居民对便捷、高效服务的期待。信息技术的快速发展为物业管理带来了新的解决方案，其中物业管理小程序作为一种
    
                    
    • 
                    
  • springboot/java/php/node/python生鲜配送小程序【计算机毕设】
                        php-毕业源码设计
javaspringbootphp
                        
    本系统（程序+源码）带文档lw万字以上文末可领取本课题的JAVA源码参考系统程序文件列表系统的选题背景和意义选题背景：随着移动互联网技术的飞速发展，人们的生活方式正在发生深刻的变化。特别是在饮食习惯上，快节奏的生活使得越来越多的人倾向于选择线上购物，以节省时间和成本。生鲜配送小程序应运而生，它通过整合供应链资源，提供从下单、支付到配送的一站式服务，极大地便利了用户购买新鲜食品的过程。这种模式不仅满
    
                    
    • 
                    
  • springboot/java/php/node/python基于微信小程序在线抽签系统【计算机毕设】
                        php-毕业源码设计
javaspringbootphp
                        
    本系统（程序+源码）带文档lw万字以上文末可领取本课题的JAVA源码参考系统程序文件列表系统的选题背景和意义选题背景：随着互联网技术的飞速发展，微信小程序以其便捷性和易用性在人们的日常生活中扮演着越来越重要的角色。从简单的信息查询到复杂的商务交易，小程序几乎渗透到了生活的每一个角落。特别是在移动互联网时代，人们对于快速、高效解决问题的需求日益增长，而传统的抽签方式由于其物理性质限制，无法满足现代人
    
                    
    • 
                    
  • Springboot/java/node/python/php基于微信小程序的二手商城【2024年毕设】
                        阿诚程序
javaspringboot微信小程序
                        
    本系统带文档lw万字以上文末可领取本课题的JAVA源码参考开发环境开发语言：Java框架：Springboot技术：springboot+vueJDK版本：JDK1.8服务器：tomcat7数据库：mysql5.7或8.0数据库工具：Navicat11开发软件：eclipse/myeclipse/ideaMaven包：Maven3.3.9浏览器：建议谷歌浏览器或edge功能模块系统界面2023-2
    
                    
    • 
                    
  • Springboot/java/node/python/php基于微信小程序的社交系统【2024年毕设】
                        灵军程序设计
javaspringboot微信小程序
                        
    本系统带文档lw万字以上文末可领取本课题的JAVA源码参考开发环境开发语言：Java框架：Springboot技术：springboot+vueJDK版本：JDK1.8服务器：tomcat7数据库：mysql5.7或8.0数据库工具：Navicat11开发软件：eclipse/myeclipse/ideaMaven包：Maven3.3.9浏览器：建议谷歌浏览器或edge功能模块系统界面2023-2
    
                    
    • 
                    
  • Springboot/java/node/python/php基于微信支付的在线打印微信小程序【2024年毕设】
                        灵军程序设计
javaspringboot微信小程序
                        
    本系统带文档lw万字以上文末可领取本课题的JAVA源码参考开发环境开发语言：Java框架：Springboot技术：springboot+vueJDK版本：JDK1.8服务器：tomcat7数据库：mysql5.7或8.0数据库工具：Navicat11开发软件：eclipse/myeclipse/ideaMaven包：Maven3.3.9浏览器：建议谷歌浏览器或edge功能模块系统界面2023-2
    
                    
    • 
                    
  • Springboot/java/node/python/php基于微信小程序的奶茶商城【2024年毕设】
                        扬基程序
javaspringboot微信小程序
                        
    本系统带文档lw万字以上文末可领取本课题的JAVA源码参考开发环境开发语言：Java框架：Springboot技术：springboot+vueJDK版本：JDK1.8服务器：tomcat7数据库：mysql5.7或8.0数据库工具：Navicat11开发软件：eclipse/myeclipse/ideaMaven包：Maven3.3.9浏览器：建议谷歌浏览器或edge功能模块系统界面2023-2
    
                    
    • 
                    
  • springboot/java/php/node/python微信宠物商店小程序【计算机毕设】
                        php-毕业源码设计
javaspringbootphp
                        
    本系统（程序+源码）带文档lw万字以上文末可领取本课题的JAVA源码参考系统程序文件列表系统的选题背景和意义选题背景：在数字化时代，微信小程序作为一种新型的应用形式，以其便捷性和高效性迅速融入人们的日常生活中。特别是对于现代都市人而言，忙碌的生活节奏往往难以腾出时间来照顾宠物或是前往宠物店挑选宠物及相关用品。随着人们生活水平的提高和对精神生活需求的增加，宠物已经成为很多家庭的重要成员，宠物行业也随
    
                    
    • 
                    
  • 音乐交流平台(JSP+java+springmvc+mysql+MyBatis)
                        怡景毕设项目
javamysqlmybatis
                        
    本项目包含程序+源码+数据库+LW+调试部署环境，文末可获取一份本项目的java源码和数据库参考。项目文件图项目介绍在数字化时代背景下，音乐爱好者之间交流与分享的需求日益增长。传统的音乐交流方式如线下聚会、音乐杂志等受到时空限制，难以满足现代人快速、便捷、多元化的交流需求。因此，打造一个线上音乐交流平台显得尤为重要。这样的平台能够为音乐爱好者提供一个广阔的空间，实现音乐作品的上传、分享、讨论和反馈
    
                    
    • 
                    
  • 智健体检中心管理网站(JSP+java+springmvc+mysql+MyBatis)
                        怡景毕设项目
javamysqlmybatis
                        
    本项目包含程序+源码+数据库+LW+调试部署环境，文末可获取一份本项目的java源码和数据库参考。项目文件图项目介绍随着健康管理意识的增强和互联网技术的应用，智健体检中心管理网站的构建成为提升体检服务效率、满足人们健康管理需求的重要工具。传统的体检中心多依赖于线下操作和手工记录，存在工作效率低下、信息更新不及时等问题。因此，开发一个集预约、报告查询、健康档案管理和健康咨询于一体的智健体检中心管理网
    
                    
    • 
                                
  • PHP，安卓，UI，java，linux视频教程合集
                                    cocos2d-x小菜
javaUIPHPandroidlinux
                                    
    ╔-----------------------------------╗┆                           
    
                                
    • 
                                
  • 各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。
                                    bozch
.net.net mvc
                                    
    在.net mvc5中，在执行某一操作的时候，出现了如下错误： 
      各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 
经查询当前的操作与错误内容无关，经过对错误信息的排查发现，事故出现在数据库迁移上。 
回想过去： 在迁移之前已经对数据库进行了添加字段操作，再次进行迁移插入XXX字段的时候，就会提示如上错误。  
&
    
                                
    • 
                                
  • Java 对象大小的计算
                                    e200702084
java
                                    
                              Java对象的大小 
 
如何计算一个对象的大小呢？ 
 
 
   
    
                                
    • 
                                
  • Mybatis Spring
                                    171815164
mybatis
                                    
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
CustomerService userService = (CustomerService) ac.getBean("customerService");
Customer cust
    
                                
    • 
                                
  • JVM 不稳定参数
                                    g21121
jvm
                                    
            -XX 参数被称为不稳定参数，之所以这么叫是因为此类参数的设置很容易引起JVM 性能上的差异，使JVM 存在极大的不稳定性。当然这是在非合理设置的前提下，如果此类参数设置合理讲大大提高JVM 的性能及稳定性。        可以说“不稳定参数”
    
                                
    • 
                                
  • 用户自动登录网站
                                    永夜-极光
用户
                                    
    1.目标:实现用户登录后,再次登录就自动登录,无需用户名和密码 
2.思路:将用户的信息保存为cookie 
           每次用户访问网站,通过filter拦截所有请求,在filter中读取所有的cookie,如果找到了保存登录信息的cookie,那么在cookie中读取登录信息,然后直接
    
                                
    • 
                                
  • centos7 安装后失去win7的引导记录
                                    程序员是怎么炼成的
操作系统
                                    
    1.使用root身份(必须)打开 /boot/grub2/grub.cfg 2.找到 ### BEGIN /etc/grub.d/30_os-prober ###   在后面添加    menuentry "Windows 7 (loader) (on /dev/sda1)" { 
    
                                
    • 
                                
  • Oracle 10g 官方中文安装帮助文档以及Oracle官方中文教程文档下载
                                    aijuans
oracle
                                    
    Oracle 10g 官方中文安装帮助文档下载：http://download.csdn.net/tag/Oracle%E4%B8%AD%E6%96%87API%EF%BC%8COracle%E4%B8%AD%E6%96%87%E6%96%87%E6%A1%A3%EF%BC%8Coracle%E5%AD%A6%E4%B9%A0%E6%96%87%E6%A1%A3 Oracle 10g 官方中文教程
    
                                
    • 
                                
  • JavaEE开源快速开发平台G4Studio_V3.2发布了
                                    無為子
AOPoraclemysqljavaeeG4Studio
                                    
      
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V3.2版本已经正式发布。大家可以通过如下地址下载。 
  
访问G4Studio网站  
http://www.g4it.org      
G4Studio_V3.2版本变更日志 
功能新增 
(1).新增了系统右下角滑出提示窗口功能。 
(2).新增了文件资源的Zip压缩和解压缩
    
                                
    • 
                                
  • Oracle常用的单行函数应用技巧总结
                                    百合不是茶
日期函数转换函数(核心)数字函数通用函数(核心)字符函数
                                    
    单行函数;   字符函数,数字函数,日期函数,转换函数(核心),通用函数(核心) 
一:字符函数: 
   .UPPER(字符串) 将字符串转为大写
   .LOWER (字符串) 将字符串转为小写 
   .INITCAP(字符串) 将首字母大写
   .LENGTH (字符串) 字符串的长度
   .REPLACE(字符串,'A','_') 将字符串字符A转换成_

    
                                
    • 
                                
  • Mockito异常测试实例
                                    bijian1013
java单元测试mockito
                                    
    Mockito异常测试实例： 
package com.bijian.study;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import org.junit.Assert;
import org.junit.Test;

import org.mockito.
    
                                
    • 
                                
  • GA与量子恒道统计
                                    Bill_chen
JavaScript浏览器百度Google防火墙
                                    
    前一阵子，统计**网址时，Google Analytics（GA） 和量子恒道统计（也称量子统计），数据有较大的偏差，仔细找相关资料研究了下，总结如下： 
  
为何GA和量子网站统计（量子统计前身为雅虎统计）结果不同？ 
首先：没有一种网站统计工具能保证百分之百的准确出现该问题可能有以下几个原因：（1）不同的统计分析系统的算法机制不同；（2）统计代码放置的位置和前后
    
                                
    • 
                                
  • 【Linux命令三】Top命令
                                    bit1129
linux命令
                                    
    Linux的Top命令类似于Windows的任务管理器，可以查看当前系统的运行情况，包括CPU、内存的使用情况等。如下是一个Top命令的执行结果： 
  
  
top - 21:22:04 up 1 day, 23:49, 1 user, load average: 1.10, 1.66, 1.99
Tasks: 202 total,   4 running, 198 sl
    
                                
    • 
                                
  • spring四种依赖注入方式
                                    白糖_
spring
                                    
       平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我
    
                                
    • 
                                
  • angular.injector
                                    boyitech
AngularJSAngularJS API
                                    
    angular.injector 
   描述:   创建一个injector对象, 调用injector对象的方法可以获得angular的service, 或者用来做依赖注入.        使用方法:   angular.injector(modules, [strictDi])        参数详解:      Param Type Details   mod
    
                                
    • 
                                
  • java-同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待
                                    bylijinnan
Integer
                                    
    

public class PC {

	/**
	 * 题目：生产者-消费者。
	 * 同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待。
	 */
	
	private static final Integer[] val=new Integer[10];
	private static
    
                                
    • 
                                
  • 使用Struts2.2.1配置
                                    Chen.H
apachespringWebxmlstruts
                                    
    Struts2.2.1 需要如下 jar包: commons-fileupload-1.2.1.jar commons-io-1.3.2.jar commons-logging-1.0.4.jar freemarker-2.3.16.jar javassist-3.7.ga.jar ognl-3.0.jar spring.jar 
struts2-core-2.2.1.jar struts2-sp
    
                                
    • 
                                
  • [职业与教育]青春之歌
                                    comsci
教育
                                    
     
 
       每个人都有自己的青春之歌............但是我要说的却不是青春... 
 
       大家如果在自己的职业生涯没有给自己以后创业留一点点机会,仅仅凭学历和人脉关系,是难以在竞争激烈的市场中生存下去的.... 
 
  &nbs
    
                                
    • 
                                
  • oracle连接(join)中使用using关键字
                                    daizj
JOINoraclesqlusing
                                    
    在oracle连接(join)中使用using关键字 
34. View the Exhibit and examine the structure of the ORDERS and ORDER_ITEMS tables. 
Evaluate the following SQL statement: 
SELECT oi.order_id, product_id, order_date 
FRO
    
                                
    • 
                                
  • NIO示例
                                    daysinsun
nio
                                    
    NIO服务端代码： 
 

public class NIOServer {
	
	private Selector selector;

	
	public void startServer(int port) throws IOException {

		ServerSocketChannel serverChannel = ServerSocketChannel.open(
    
                                
    • 
                                
  • C语言学习homework1
                                    dcj3sjt126com
chomework
                                    
    0、 课堂练习做完 
1、使用sizeof计算出你所知道的所有的类型占用的空间。 
int x; 
sizeof(x); 
  
sizeof(int); 
  
# include <stdio.h>

int main(void)
{
	int x1;
	char x2;
	double x3;
	float x4;

	printf(&quo
    
                                
    • 
                                
  • select in order by , mysql排序
                                    dcj3sjt126com
mysql
                                    
    If i select like this: 
SELECT id FROM users WHERE id IN(3,4,8,1); 
This by default will select users in this order 
1,3,4,8, 
I would like to select them in the same order that i put IN() values so: 
    
                                
    • 
                                
  • 页面校验-新建项目
                                    fanxiaolong
页面校验
                                    
    $(document).ready(
	function() {
			var flag = true;
		$('#changeform').submit(function() {
			var projectScValNull = true;
			var s ="";
			var parent_id = $("#parent_id").v
    
                                
    • 
                                
  • Ehcache（02）——ehcache.xml简介
                                    234390216
ehcacheehcache.xml简介
                                    
    ehcache.xml简介 
  
       ehcache.xml文件是用来定义Ehcache的配置信息的，更准确的来说它是定义CacheManager的配置信息的。根据之前我们在《Ehcache简介》一文中对CacheManager的介绍我们知道一切Ehcache的应用都是从CacheManager开始的。在不指定配置信
    
                                
    • 
                                
  • junit 4.11中三个新功能
                                    jackyrong
java
                                    
    junit 4.11中两个新增的功能，首先是注解中可以参数化，比如 
 
 


import static org.junit.Assert.assertEquals;
 
import java.util.Arrays;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runn
    
                                
    • 
                                
  • 国外程序员爱用苹果Mac电脑的10大理由
                                    php教程分享
windowsPHPunixMicrosoftperl
                                    
    Mac 在国外很受欢迎，尤其是在 设计/web开发/IT 人员圈子里。普通用户喜欢 Mac 可以理解，毕竟 Mac 设计美观，简单好用，没有病毒。那么为什么专业人士也对 Mac 情有独钟呢？从个人使用经验来看我想有下面几个原因： 
1、Mac OS X 是基于 Unix 的 
这一点太重要了，尤其是对开发人员，至少对于我来说很重要，这意味着Unix 下一堆好用的工具都可以随手捡到。如果你是个 wi
    
                                
    • 
                                
  • 位运算、异或的实际应用
                                    wenjinglian
位运算
                                    
    一． 位操作基础，用一张表描述位操作符的应用规则并详细解释。 
      二． 常用位操作小技巧，有判断奇偶、交换两数、变换符号、求绝对值。 
      三． 位操作与空间压缩，针对筛素数进行空间压缩。 
   &n
    
                                
    • 
                                
  • weblogic部署项目出现的一些问题（持续补充中……）
                                    Everyday都不同
weblogic部署失败
                                    
    好吧，weblogic的问题确实…… 
  
问题一： 
org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [zip:E:/weblogic/user_projects/domains/base_domain/serve
    
                                
    • 
                                
  • tomcat7性能调优（01）
                                    toknowme
tomcat7
                                    
      
    
Tomcat优化：   1、最大连接数最大线程等设置    
<Connector port="8082" protocol="HTTP/1.1" 
               useBodyEncodingForURI="t
    
                                
    • 
                                
  • PO VO DAO DTO BO TO概念与区别
                                    xp9802
javaDAO设计模式bean领域模型
                                    
    O/R Mapping 是 Object Relational Mapping（对象关系映射）的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的东东需要了解，即VO，PO。 
它们的关系应该是相互独立的，一个VO可以只是PO的部分，也可以是多个PO构成，同样也可以等同于一个PO（指的是他们的属性）。这样，PO独立出来，数据持
    
                                
    •