create core-java-io module (#3397)

* make sure modules using java8

* move url matching code

* upgrade boot parent

* minor cleanup

* fix blocking tests

* add core-java-io module

core-java-io/src/main/java/com/baeldung/dirmonitoring/DirectoryMonitoringExample.java

@@ -0,0 +1,42 @@
+package com.baeldung.dirmonitoring;
+
+import org.apache.commons.io.monitor.FileAlterationListener;
+import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;
+import org.apache.commons.io.monitor.FileAlterationMonitor;
+import org.apache.commons.io.monitor.FileAlterationObserver;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+
+public class DirectoryMonitoringExample {
+
+    private static final Logger LOG = LoggerFactory.getLogger(DirectoryMonitoringExample.class);
+
+    private static final int POLL_INTERVAL = 500;
+
+    public static void main(String[] args) throws Exception {
+        FileAlterationObserver observer = new FileAlterationObserver(System.getProperty("user.home"));
+        FileAlterationMonitor monitor = new FileAlterationMonitor(POLL_INTERVAL);
+        FileAlterationListener listener = new FileAlterationListenerAdaptor() {
+            @Override
+            public void onFileCreate(File file) {
+                LOG.debug("File: " + file.getName() + " created");
+            }
+
+            @Override
+            public void onFileDelete(File file) {
+                LOG.debug("File: " + file.getName() + " deleted");
+            }
+
+            @Override
+            public void onFileChange(File file) {
+                LOG.debug("File: " + file.getName() + " changed");
+            }
+        };
+        observer.addListener(listener);
+        monitor.addObserver(observer);
+        monitor.start();
+
+    }
+}

core-java-io/src/main/java/com/baeldung/filesystem/jndi/LookupFSJNDI.java

@@ -0,0 +1,42 @@
+package com.baeldung.filesystem.jndi;
+
+import java.io.File;
+import java.util.Hashtable;
+
+import javax.naming.Context;
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+
+public class LookupFSJNDI {
+    private InitialContext ctx = null;
+
+    public LookupFSJNDI() throws NamingException {
+        super();
+        init();
+    }
+
+    private void init() throws NamingException {
+        Hashtable<String, String> env = new Hashtable<String, String>();
+
+        env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory");
+        // URI to namespace (actual directory)
+        env.put(Context.PROVIDER_URL, "file:./src/test/resources");
+
+        ctx = new InitialContext(env);
+    }
+
+    public InitialContext getCtx() {
+        return ctx;
+    }
+
+    public File getFile(String fileName) {
+        File file;
+        try {
+            file = (File) getCtx().lookup(fileName);
+        } catch (NamingException e) {
+            file = null;
+        }
+        return file;
+    }
+
+}

core-java-io/src/main/java/com/baeldung/java/nio/selector/EchoClient.java

@@ -0,0 +1,50 @@
+package com.baeldung.java.nio.selector;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.SocketChannel;
+
+public class EchoClient {
+    private static SocketChannel client;
+    private static ByteBuffer buffer;
+    private static EchoClient instance;
+
+    public static EchoClient start() {
+        if (instance == null)
+            instance = new EchoClient();
+
+        return instance;
+    }
+
+    public static void stop() throws IOException {
+        client.close();
+        buffer = null;
+    }
+
+    private EchoClient() {
+        try {
+            client = SocketChannel.open(new InetSocketAddress("localhost", 5454));
+            buffer = ByteBuffer.allocate(256);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public String sendMessage(String msg) {
+        buffer = ByteBuffer.wrap(msg.getBytes());
+        String response = null;
+        try {
+            client.write(buffer);
+            buffer.clear();
+            client.read(buffer);
+            response = new String(buffer.array()).trim();
+            System.out.println("response=" + response);
+            buffer.clear();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return response;
+
+    }
+}

core-java-io/src/main/java/com/baeldung/java/nio/selector/EchoServer.java

@@ -0,0 +1,75 @@
+package com.baeldung.java.nio.selector;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
+import java.nio.channels.ServerSocketChannel;
+import java.nio.channels.SocketChannel;
+import java.util.Iterator;
+import java.util.Set;
+
+public class EchoServer {
+
+    private static final String POISON_PILL = "POISON_PILL";
+
+    public static void main(String[] args) throws IOException {
+        Selector selector = Selector.open();
+        ServerSocketChannel serverSocket = ServerSocketChannel.open();
+        serverSocket.bind(new InetSocketAddress("localhost", 5454));
+        serverSocket.configureBlocking(false);
+        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
+        ByteBuffer buffer = ByteBuffer.allocate(256);
+
+        while (true) {
+            selector.select();
+            Set<SelectionKey> selectedKeys = selector.selectedKeys();
+            Iterator<SelectionKey> iter = selectedKeys.iterator();
+            while (iter.hasNext()) {
+
+                SelectionKey key = iter.next();
+
+                if (key.isAcceptable()) {
+                    register(selector, serverSocket);
+                }
+
+                if (key.isReadable()) {
+                    answerWithEcho(buffer, key);
+                }
+                iter.remove();
+            }
+        }
+    }
+
+    private static void answerWithEcho(ByteBuffer buffer, SelectionKey key) throws IOException {
+        SocketChannel client = (SocketChannel) key.channel();
+        client.read(buffer);
+        if (new String(buffer.array()).trim().equals(POISON_PILL)) {
+            client.close();
+            System.out.println("Not accepting client messages anymore");
+        }
+
+        buffer.flip();
+        client.write(buffer);
+        buffer.clear();
+    }
+
+    private static void register(Selector selector, ServerSocketChannel serverSocket) throws IOException {
+        SocketChannel client = serverSocket.accept();
+        client.configureBlocking(false);
+        client.register(selector, SelectionKey.OP_READ);
+    }
+
+    public static Process start() throws IOException, InterruptedException {
+        String javaHome = System.getProperty("java.home");
+        String javaBin = javaHome + File.separator + "bin" + File.separator + "java";
+        String classpath = System.getProperty("java.class.path");
+        String className = EchoServer.class.getCanonicalName();
+
+        ProcessBuilder builder = new ProcessBuilder(javaBin, "-cp", classpath, className);
+
+        return builder.start();
+    }
+}

core-java-io/src/main/java/com/baeldung/java/nio/selector/README.md

@@ -0,0 +1,2 @@
+###Relevant Articles:
+- [Introduction to the Java NIO Selector](http://www.baeldung.com/java-nio-selector)

core-java-io/src/main/java/com/baeldung/java/nio2/visitor/FileSearchExample.java

@@ -0,0 +1,56 @@
+package com.baeldung.java.nio2.visitor;
+
+import java.io.IOException;
+import java.nio.file.*;
+import java.nio.file.attribute.BasicFileAttributes;
+
+import static java.nio.file.FileVisitResult.CONTINUE;
+import static java.nio.file.FileVisitResult.TERMINATE;
+
+public class FileSearchExample implements FileVisitor<Path> {
+    private final String fileName;
+    private final Path startDir;
+
+    public FileSearchExample(String fileName, Path startingDir) {
+        this.fileName = fileName;
+        startDir = startingDir;
+    }
+
+    @Override
+    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
+        return CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+        String fileName = file.getFileName().toString();
+        if (this.fileName.equals(fileName)) {
+            System.out.println("File found: " + file.toString());
+            return TERMINATE;
+        }
+        return CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
+        System.out.println("Failed to access file: " + file.toString());
+        return CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
+        boolean finishedSearch = Files.isSameFile(dir, startDir);
+        if (finishedSearch) {
+            System.out.println("File:" + fileName + " not found");
+            return TERMINATE;
+        }
+        return CONTINUE;
+    }
+
+    public static void main(String[] args) throws IOException {
+        Path startingDir = Paths.get("C:/Users/new/Desktop");
+        FileSearchExample crawler = new FileSearchExample("hibernate.txt", startingDir);
+        Files.walkFileTree(startingDir, crawler);
+    }
+
+}

core-java-io/src/main/java/com/baeldung/java/nio2/visitor/FileVisitorImpl.java

@@ -0,0 +1,30 @@
+package com.baeldung.java.nio2.visitor;
+
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.FileVisitor;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
+
+public class FileVisitorImpl implements FileVisitor<Path> {
+
+    @Override
+    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
+        return null;
+    }
+
+    @Override
+    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
+        return null;
+    }
+
+    @Override
+    public FileVisitResult visitFileFailed(Path file, IOException exc) {
+        return null;
+    }
+
+    @Override
+    public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
+        return null;
+    }
+}

core-java-io/src/main/java/com/baeldung/java/nio2/watcher/DirectoryWatcherExample.java

@@ -0,0 +1,29 @@
+package com.baeldung.java.nio2.watcher;
+
+import java.io.IOException;
+import java.nio.file.FileSystems;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardWatchEventKinds;
+import java.nio.file.WatchEvent;
+import java.nio.file.WatchKey;
+import java.nio.file.WatchService;
+
+public class DirectoryWatcherExample {
+    
+    public static void main(String[] args) throws IOException, InterruptedException {
+        WatchService watchService = FileSystems.getDefault().newWatchService();
+        Path path = Paths.get(System.getProperty("user.home"));
+        path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY);
+        WatchKey key;
+        while ((key = watchService.take()) != null) {
+            for (WatchEvent<?> event : key.pollEvents()) {
+                System.out.println("Event kind:" + event.kind() + ". File affected: " + event.context() + ".");
+            }
+            key.reset();
+        }
+
+        watchService.close();
+    }
+    
+}

core-java-io/src/main/java/com/baeldung/stream/FileCopy.java

@@ -0,0 +1,48 @@
+package com.baeldung.stream;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+
+import org.apache.commons.io.FileUtils;
+
+public class FileCopy {
+
+    public static void copyFileUsingStream(File source, File dest) throws IOException {
+        InputStream is = null;
+        OutputStream os = null;
+        is = new FileInputStream(source);
+        os = new FileOutputStream(dest);
+        byte[] buffer = new byte[1024];
+        int length;
+        while ((length = is.read(buffer)) > 0) {
+            os.write(buffer, 0, length);
+        }
+        is.close();
+        os.close();
+    }
+
+    public static void copyFileUsingChannel(File source, File dest) throws IOException {
+        FileChannel sourceChannel = null;
+        FileChannel destChannel = null;
+        sourceChannel = new FileInputStream(source).getChannel();
+        destChannel = new FileOutputStream(dest).getChannel();
+        destChannel.transferFrom(sourceChannel, 0, sourceChannel.size());
+        sourceChannel.close();
+        destChannel.close();
+    }
+
+    public static void copyFileUsingApacheCommonsIO(File source, File dest) throws IOException {
+        FileUtils.copyFile(source, dest);
+    }
+
+    public static void copyFileUsingJavaFiles(File source, File dest) throws IOException {
+        Files.copy(source.toPath(), dest.toPath());
+    }
+
+}

core-java-io/src/main/java/com/baeldung/stream/StreamIndices.java

@@ -0,0 +1,62 @@
+package com.baeldung.stream;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import com.codepoetics.protonpack.Indexed;
+import com.codepoetics.protonpack.StreamUtils;
+
+import io.vavr.collection.Stream;
+import one.util.streamex.EntryStream;
+
+public class StreamIndices {
+
+    public static List<String> getEvenIndexedStrings(String[] names) {
+        List<String> evenIndexedNames = IntStream.range(0, names.length)
+            .filter(i -> i % 2 == 0)
+            .mapToObj(i -> names[i])
+            .collect(Collectors.toList());
+        return evenIndexedNames;
+    }
+
+    public List<String> getEvenIndexedStringsVersionTwo(List<String> names) {
+        List<String> evenIndexedNames = EntryStream.of(names)
+            .filterKeyValue((index, name) -> index % 2 == 0)
+            .values()
+            .toList();
+        return evenIndexedNames;
+    }
+
+    public static List<Indexed<String>> getEvenIndexedStrings(List<String> names) {
+        List<Indexed<String>> list = StreamUtils.zipWithIndex(names.stream())
+            .filter(i -> i.getIndex() % 2 == 0)
+            .collect(Collectors.toList());
+        return list;
+    }
+
+    public static List<Indexed<String>> getOddIndexedStrings(List<String> names) {
+        List<Indexed<String>> list = StreamUtils.zipWithIndex(names.stream())
+            .filter(i -> i.getIndex() % 2 == 1)
+            .collect(Collectors.toList());
+        return list;
+    }
+
+    public static List<String> getOddIndexedStrings(String[] names) {
+        List<String> oddIndexedNames = IntStream.range(0, names.length)
+            .filter(i -> i % 2 == 1)
+            .mapToObj(i -> names[i])
+            .collect(Collectors.toList());
+        return oddIndexedNames;
+    }
+
+    public static List<String> getOddIndexedStringsVersionTwo(String[] names) {
+        List<String> oddIndexedNames = Stream.of(names)
+            .zipWithIndex()
+            .filter(tuple -> tuple._2 % 2 == 1)
+            .map(tuple -> tuple._1)
+            .toJavaList();
+        return oddIndexedNames;
+    }
+
+}

core-java-io/src/main/java/com/baeldung/unzip/UnzipFile.java

@@ -0,0 +1,30 @@
+package com.baeldung.unzip;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+public class UnzipFile {
+    public static void main(final String[] args) throws IOException {
+        final String fileZip = "src/main/resources/compressed.zip";
+        final byte[] buffer = new byte[1024];
+        final ZipInputStream zis = new ZipInputStream(new FileInputStream(fileZip));
+        ZipEntry zipEntry = zis.getNextEntry();
+        while (zipEntry != null) {
+            final String fileName = zipEntry.getName();
+            final File newFile = new File("src/main/resources/unzipTest/" + fileName);
+            final FileOutputStream fos = new FileOutputStream(newFile);
+            int len;
+            while ((len = zis.read(buffer)) > 0) {
+                fos.write(buffer, 0, len);
+            }
+            fos.close();
+            zipEntry = zis.getNextEntry();
+        }
+        zis.closeEntry();
+        zis.close();
+    }
+}

core-java-io/src/main/java/com/baeldung/util/StreamUtils.java

@@ -0,0 +1,16 @@
+package com.baeldung.util;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringWriter;
+
+import org.apache.commons.io.IOUtils;
+
+public class StreamUtils {
+
+    public static String getStringFromInputStream(InputStream input) throws IOException {
+        StringWriter writer = new StringWriter();
+        IOUtils.copy(input, writer, "UTF-8");
+        return writer.toString();
+    }
+}

core-java-io/src/main/java/com/baeldung/zip/ZipDirectory.java

@@ -0,0 +1,43 @@
+package com.baeldung.zip;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+public class ZipDirectory {
+    public static void main(final String[] args) throws IOException {
+        final String sourceFile = "src/main/resources/zipTest";
+        final FileOutputStream fos = new FileOutputStream("src/main/resources/dirCompressed.zip");
+        final ZipOutputStream zipOut = new ZipOutputStream(fos);
+        final File fileToZip = new File(sourceFile);
+
+        zipFile(fileToZip, fileToZip.getName(), zipOut);
+        zipOut.close();
+        fos.close();
+    }
+
+    private static void zipFile(final File fileToZip, final String fileName, final ZipOutputStream zipOut) throws IOException {
+        if (fileToZip.isHidden()) {
+            return;
+        }
+        if (fileToZip.isDirectory()) {
+            final File[] children = fileToZip.listFiles();
+            for (final File childFile : children) {
+                zipFile(childFile, fileName + "/" + childFile.getName(), zipOut);
+            }
+            return;
+        }
+        final FileInputStream fis = new FileInputStream(fileToZip);
+        final ZipEntry zipEntry = new ZipEntry(fileName);
+        zipOut.putNextEntry(zipEntry);
+        final byte[] bytes = new byte[1024];
+        int length;
+        while ((length = fis.read(bytes)) >= 0) {
+            zipOut.write(bytes, 0, length);
+        }
+        fis.close();
+    }
+}

core-java-io/src/main/java/com/baeldung/zip/ZipFile.java

@@ -0,0 +1,28 @@
+package com.baeldung.zip;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+public class ZipFile {
+    public static void main(final String[] args) throws IOException {
+        final String sourceFile = "src/main/resources/zipTest/test1.txt";
+        final FileOutputStream fos = new FileOutputStream("src/main/resources/compressed.zip");
+        final ZipOutputStream zipOut = new ZipOutputStream(fos);
+        final File fileToZip = new File(sourceFile);
+        final FileInputStream fis = new FileInputStream(fileToZip);
+        final ZipEntry zipEntry = new ZipEntry(fileToZip.getName());
+        zipOut.putNextEntry(zipEntry);
+        final byte[] bytes = new byte[1024];
+        int length;
+        while ((length = fis.read(bytes)) >= 0) {
+            zipOut.write(bytes, 0, length);
+        }
+        zipOut.close();
+        fis.close();
+        fos.close();
+    }
+}

core-java-io/src/main/java/com/baeldung/zip/ZipMultipleFiles.java

@@ -0,0 +1,33 @@
+package com.baeldung.zip;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+public class ZipMultipleFiles {
+    public static void main(final String[] args) throws IOException {
+        final List<String> srcFiles = Arrays.asList("src/main/resources/zipTest/test1.txt", "src/main/resources/zipTest/test2.txt");
+        final FileOutputStream fos = new FileOutputStream("src/main/resources/multiCompressed.zip");
+        final ZipOutputStream zipOut = new ZipOutputStream(fos);
+        for (final String srcFile : srcFiles) {
+            final File fileToZip = new File(srcFile);
+            final FileInputStream fis = new FileInputStream(fileToZip);
+            final ZipEntry zipEntry = new ZipEntry(fileToZip.getName());
+            zipOut.putNextEntry(zipEntry);
+
+            final byte[] bytes = new byte[1024];
+            int length;
+            while ((length = fis.read(bytes)) >= 0) {
+                zipOut.write(bytes, 0, length);
+            }
+            fis.close();
+        }
+        zipOut.close();
+        fos.close();
+    }
+}

core-java-io/src/main/resources/META-INF/persistence.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
+        http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd" version="2.1">
+
+    <!-- JDO tutorial "unit" -->
+    <persistence-unit name="Tutorial">
+        <exclude-unlisted-classes/>
+		<properties>
+			<property name="javax.jdo.PersistenceManagerFactoryClass" value="org.datanucleus.api.jdo.JDOPersistenceManagerFactory"/>		
+		    <property name="javax.jdo.option.ConnectionURL" value="jdbc:h2:mem:mypersistence"/>
+		    <property name="javax.jdo.option.ConnectionDriverName" value="org.h2.Driver"/>
+		    <property name="javax.jdo.option.ConnectionUserName" value="sa"/>
+		    <property name="javax.jdo.option.ConnectionPassword" value=""/>
+		    <property name="datanucleus.schema.autoCreateAll" value="true"/>
+		</properties>
+    </persistence-unit>
+</persistence>
+

core-java-io/src/main/resources/META-INF/services/com.sun.source.util.Plugin

@@ -0,0 +1 @@
+com.baeldung.javac.SampleJavacPlugin

core-java-io/src/main/resources/countries.properties

@@ -0,0 +1,3 @@
+UK
+US
+Germany

core-java-io/src/main/resources/data.csv

@@ -0,0 +1,3 @@
+1|IND|India
+2|MY|Malaysia
+3|AU|Australia

core-java-io/src/main/resources/datasource.properties

@@ -0,0 +1,6 @@
+dataSourceClassName=//TBD
+dataSource.user=//TBD
+dataSource.password=//TBD
+dataSource.databaseName=//TBD
+dataSource.portNumber=//TBD
+dataSource.serverName=//TBD

core-java-io/src/main/resources/js/bind.js

@@ -0,0 +1,15 @@
+var first = {
+    name: "Whiskey",
+    age: 5
+};
+
+var second = {
+    volume: 100
+};
+
+Object.bindProperties(first, second);
+
+print(first.volume);
+
+second.volume = 1000;
+print(first.volume);

core-java-io/src/main/resources/js/locations.js

@@ -0,0 +1 @@
+print(__FILE__, __LINE__, __DIR__);

core-java-io/src/main/resources/js/math_module.js

@@ -0,0 +1,19 @@
+var math = {
+    increment: function (num) {
+        return ++num;
+    },
+
+    failFunc: function () {
+        try {
+            throw "BOOM";
+        } catch (e if typeof e === 'string') {
+            print("String thrown: " + e);
+        }
+        catch (e) {
+            print("this shouldn't happen!");
+        }
+    }
+};
+
+
+math;

core-java-io/src/main/resources/js/no_such.js

@@ -0,0 +1,11 @@
+var demo = {
+    __noSuchProperty__: function (propName) {
+        print("Accessed non-existing property: " + propName);
+    },
+
+    __noSuchMethod__: function (methodName) {
+        print("Invoked non-existing method: " + methodName);
+    }
+};
+
+demo;

core-java-io/src/main/resources/js/script.js

@@ -0,0 +1 @@
+function increment(num) ++num;

core-java-io/src/main/resources/js/trim.js

@@ -0,0 +1,2 @@
+print("   hello world".trimLeft());
+print("hello world     ".trimRight());

core-java-io/src/main/resources/js/typed_arrays.js

@@ -0,0 +1,9 @@
+function arrays(arr) {
+
+    var javaIntArray = Java.to(arr, "int[]");
+    print(javaIntArray[0]);
+    print(javaIntArray[1]);
+    print(javaIntArray[2]);
+}
+
+arrays([100, "1654", true]);