import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.RandomAccessFile;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;

public class FileIOToolKit {

public FileIOToolKit() {

}

public static byte[] read(String filename) throws IOException {
return read(new File(filename));
}

public static byte[] read(File file) throws IOException {
byte[] in;
try (FileInputStream fis = new FileInputStream(file);) {
in = new byte[(int) file.length()];
fis.read(in);
}
catch (Exception e) {
throw e;
}
return in;
}

public static String readString(File file) throws IOException {
return readString(file, true);
}

public static String readString(File file, boolean reConstructEndOfLines) throws IOException {
StringBuilder buf = new StringBuilder();
try (BufferedReader in = new BufferedReader(new FileReader(file))) {
String str;
while ((str = in.readLine()) != null) {
if (reConstructEndOfLines) {
buf.append(str + "\n");
}
else {
buf.append(str);
}
}
}
catch (IOException e) {
throw e;
}
return buf.toString();
}

public static List<String> readStringAsList(File file) throws IOException {
List<String> buf = new ArrayList<String>();
try (BufferedReader in = new BufferedReader(new FileReader(file))) {
String str;
while ((str = in.readLine()) != null) {
buf.add(str);
}
}
catch (IOException e) {
throw e;
}
return buf;
}

public static String readString(String filename) throws IOException {
return readString(new File(filename));
}

public static String readString(String filename, boolean reConstructEndOfLines) throws IOException {
return readString(new File(filename), reConstructEndOfLines);
}

public static void write(File file, byte[] content) throws IOException {
try (RandomAccessFile rFile = new RandomAccessFile(file, "rw")) {
rFile.write(content);
}
catch (IOException e) {
throw e;
}
}

public static void write(String filename, byte[] content) throws IOException {
write(new File(filename), content);
}

public static void writeString(String filename, String content) throws IOException {
writeString(new File(filename), content, "UTF-8");
}

public static void writeStringOld(String filename, String content) throws IOException {
writeStringOld(new File(filename), content, "UTF-8");
}

public static void writeString(String filename, String content, String encoding) throws IOException {
writeString(new File(filename), content, encoding);
}

public static void writeString(File file, String content) throws IOException {
writeString(file, content, "UTF-8");
}

public static void writeString(File file, String content, String encoding) throws IOException {
try (RandomAccessFile rFile = new RandomAccessFile(file, "rw")) {
rFile.writeBytes(content);
}
catch (IOException e) {
throw e;
}
}

public static void writeStringOld(File file, String content, String encoding) throws IOException {
try (BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), encoding))) {
bw.write(content);
}
catch (IOException e) {
throw e;
}
}

public static void append(File file, byte[] content) throws IOException {
try (FileOutputStream fos = new FileOutputStream(file, true)) {
fos.write(content);

}
catch (IOException e) {
throw e;
}
}

public static void append(String filename, byte[] content) throws IOException {
append(new File(filename), content);
}

public static void appendString(File file, String content) throws IOException {
appendString(file, content, "UTF-8");
}

public static void appendString(File file, String content, String encoding) throws IOException {
try (BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, true), encoding))) {
bw.write(content);
}
catch (IOException e) {
throw e;
}
}

public static void appendString(String filename, String content) throws IOException {
appendString(new File(filename), content);
}

public static void appendString(String filename, String content, String encoding) throws IOException {
appendString(new File(filename), content, encoding);
}

private static String convertByteArrayToHexString(byte[] arrayBytes) {
StringBuffer stringBuffer = new StringBuffer();
for (int ii = 0; ii < arrayBytes.length; ii++) {
stringBuffer.append(Integer.toString((arrayBytes[ii] & 0xff) + 0x100, 16).substring(1));
}
return stringBuffer.toString();
}

public static String createMD5HashOfFile(String filename) throws IOException, NoSuchAlgorithmException {
return createMD5HashOfFile(new File(filename));
}

public static String createMD5HashOfFile(File file) throws IOException, NoSuchAlgorithmException {
MessageDigest digest = MessageDigest.getInstance("MD5");
byte[] content = read(file);
byte[] hash = digest.digest(content);
return convertByteArrayToHexString(hash);
}

public static String createMD5HashOfContent(byte[] content) throws IOException, NoSuchAlgorithmException {
MessageDigest digest = MessageDigest.getInstance("MD5");
byte[] hash = digest.digest(content);
return convertByteArrayToHexString(hash);
}
}

select ROUND(disk_reads/decode(executions,0,1,executions)/300) EXTIME, SQL_TEXT
from v$sql
where disk_reads/decode(executions,0,1,executions)/300 >1
and executions>0
order by (disk_reads/decode(executions,0,1,executions)/300) DESC

var result=null;
for(var i=0;i<chunks.length;i++){
var last=false;
if(i==(chunks.length-1)){
last=true;
}
result=uploadFileChunk(chunks,filenamePrefix+file.name,url,params,last);
}
return result;

function uploadFileChunk(chunk,filename,url,params,lastChunk) {
var formData = new FormData();
formData.append('upfile', chunk, filename);
formData.append("filename",filename);

for(key in params){
formData.append(key,params[key]);
}

if(lastChunk){
formData.append("lastChunk","true");
}
else{
formData.append("lastChunk","false");
}

var xhr = new XMLHttpRequest();

xhr.open("POST", url,false); //false=synchron;
xhr.send(formData);
console.log("upload response-text: "+xhr.responseText);
return xhr.responseText;
}

function createChunksOfFile(file,chunkSize){
var chunks=new Array();

var filesize=file.size;

var counter=0;
while(filesize>counter){
var chunk=file.slice(counter,(counter+chunkSize));
counter=counter+chunkSize;

chunks[chunks.length]=chunk;
}

return chunks;
}

var chunks=createChunksOfFile(file,250000);

<?php
//see $_REQUEST["lastChunk"] to know if it is the last chunk-part or not
if(isset($_FILES["upfile"])){
file_put_contents($_REQUEST["filename"],file_get_contents($_FILES["upfile"]["tmp_name"]),FILE_APPEND);
}
?>

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse resp) throws ServletException, IOException {
try {
String appPath = request.getServletContext().getRealPath("");

String filename = request.getParameter("filename");
for (Part part : request.getParts()) {
if (part.getName().equals("upfile")) {
byte[] out = new byte[part.getInputStream().available()];
part.getInputStream().read(out);

FileIOToolKit.append(appPath + File.separator + filename, out);
System.out.println(appPath + File.separator + filename + " saved!");
}
}
}
catch (Exception e) {
e.printStackTrace();
}
}

var files = null; // FileList object
if(!nodragndrop){
files=evt.dataTransfer.files; //input
}
else{
files=evt.target.files; //drag and drop
}

<footer style="text-align:center;">
<?php
$sm = $this->getHelperPluginManager()->getServiceLocator();
$router = $sm->get('router');
$request = $sm->get('request');
$routeMatch = $router->match($request);
$route = $routeMatch->getMatchedRouteName();
?>
<i>(Route: <?=$route?>)</i>
</footer>

if($test!=null && $test->getId()>0){
$rset = $this->select(
function (Select $select) use ($test) {
$select->where->equalTo('test_id',$category->getId());
$select->where->lessThan('test_date','CURRENT_DATETIME');
$select->order('test_date DESC')->limit(20,0);
}
);
}