http://groups.google.com/group/comp.lang.c++/msg/695ebf877e25b287

I said then: "How about reading the whole Bible, sorting by lines, and
writing the sorted book to a file?"

Who remember that from 7 years ago, one of the longest thread on this
newsgroup :)

The text file used for the bible is here
ftp://ftp.cs.princeton.edu/pub/cs126/markov/textfiles/bible.txt

Back to see if anything has changed

(downloaded whatever is latest version from sun.java.com)

Time for reading, sorting, writing: 359 ms (Java)
Time for reading, sorting, writing: 375 ms (Java)
Time for reading, sorting, writing: 375 ms (Java)

Visual C++ express and command I used was cl IOSort.cpp /O2

Time for reading, sorting, writing: 375 ms (c++)
Time for reading, sorting, writing: 390 ms (c++)
Time for reading, sorting, writing: 359 ms (c++)

The question still is (7 years later), where is great speed advantage
you guys were claiming for c++?

------------------- Java Code -------------- (same as 7 years ago :)

import java.io.*;
import java.util.*;
public class IOSort
{
    public static void main(String[] arg) throws Exception
   {
            ArrayList ar = new ArrayList(5000);

            String line = "";

            BufferedReader in = new BufferedReader(
                new FileReader("bible.txt"));
            PrintWriter out  = new PrintWriter(new BufferedWriter(
                new FileWriter("output.txt")));

            long start = System.currentTimeMillis();
            while (true)
            {
                line = in.readLine();
                if (line == null)
                  break;
                if (line.length() == 0)
                 continue;
                ar.add(line);
            }

            Collections.sort(ar);
            int size = ar.size();
            for (int i = 0; i < size; i++)
            {
                out.println(ar.get(i));
            }
            out.close();
            long end = System.currentTimeMillis();
           System.out.println("Time for reading, sorting, writing: "+
(end - start) + " ms");
   }

#include <fstream>
#include<iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <ctime>
using namespace ::std;

int main()
{
   vector<string> buf;
   string linBuf;
   ifstream inFile("bible.txt");
   clock_t start=clock();
   buf.reserve(50000);

   while(getline(inFile,linBuf)) buf.insert(buf.end(), linBuf);
   sort(buf.begin(), buf.end());
   ofstream outFile("output.txt");
   copy(buf.begin(),buf.end(),ostream_iterator<string>(outFile,"\n"));
clock_t endt=clock();
   cout <<"Time for reading, sorting, writing: " << endt-start << "
ms\n";
   return 0;

C++ will bring you closer to the hardware you are developing for, that
is one of the strengths of the language, but Java can be just as
respectable as far as performance goes. It really just depends on what
you are using the language for. Use the most appropriate tool for the
job.

Also, comparing to your results 7 years ago, it looks like Java has
slowed down a bit, relatively. :-D

Is required for ostream_iterator.

First of all, I believe this is a bad test. A lot of the time will be
involved with I/O which the compilers cant really affect. I also
notice that the time included does not involve releasing memory used
by the Java-program which is unfair as this time was measured in the C+
+ version.
Be that as it is, I notice that the C++ version is fifty percent
shorter which suggests that developing with C++ will be quite a lot
faster.
I also wonder what happens in the hypothetical case where you were
told that the solution produced was simply to slow. I know that C++
offers you lots of flexibility where you could program towards a
certain environment, using e.g. memory-mapped I/O. (*)
So all in all, the above benchmark could never make me consider
switching languages.

/Peter

Both java and c++ used the same code, so what's the problem?

You're requirement was "How about reading the whole Bible, sorting by
lines, and writing the sorted book to a file?"

Reading into a multiset and then writing out meets those requirements.

import java.io.*;  import java.util.*;  public class IOSort
{public static void main(String[] arg) throws Exception {
ArrayList<String> ar = new ArrayList<String>(50000); String line = "";
BufferedReader in = new BufferedReader( new FileReader("bible.txt"));
PrintWriter out  = new PrintWriter(new BufferedWriter(new
FileWriter("output.txt"))); long start = System.currentTimeMillis();
while (true) { line = in.readLine(); if (line == null) break;
ar.add(line);  } Collections.sort(ar); int size = ar.size();
for (int i = 0; i < size; i++) { out.println(ar.get(i));}
out.close();  long end = System.currentTimeMillis();
System.out.println("Time for reading, sorting, writing: "+ (end -
start) + " ms"); } }

I hope you are satisfied :))

On a serious note, I also removed an unneeded line, (if (line.length()
==0)  continue;) that was in the loop. That probably helped in speed.

Jason

For those who want to prove C++ faster, just do something with
large arrays of user defined types having value semantics.  For
those who want to prove Java faster, use large arrays of basic
types, or where you can swap the pointers, rather than the
values.  Like this particular example:-)---I'm really surprised
that Java didn't do a lot better.

For those who are concerned with performance in your actual
work, of course, write a benchmark which simulates your actual
work (I don't know of too many people just sorting lines in a
single large text corpus), and benchmark it, on the machine
you'll actually be running on.  (The quality of Java---and
C++---implementations varies a lot.)  In theory, Java has the
advantage in array accesses (because of the lack of aliasing);
C++ when it comes to handling user defined value types (no
allocation is even cheaper than garbage collected allocation).
In practice, however, it will depend on the implementation.

http://groups.google.com/group/comp.lang.c++/msg/695ebf877e25b287

In that case, it didn't make a difference because bible.txt I was
using had verse numbers (so there could be no duplicates). A few here
(including Pete Becker from dinkumware) claimed that I used set and it
was unfair...

In any case, I can use multiset...

Time for reading, sorting, writing: 328 ms (c++)
Time for reading, sorting, writing: 312 ms (c++)
Time for reading, sorting, writing: 312 ms (c++)

Just a little improvement only...

For Java I can try TreeSet
http://java.sun.com/javase/6/docs/api/java/util/TreeSet.html

(which I asume does something similiar -- if not, any Java expert can
correct it).

Time for reading, sorting, writing: 359 ms
Time for reading, sorting, writing: 360 ms
Time for reading, sorting, writing: 359 ms

Not much changes here ...

------ c++-------
#include <fstream>
#include<iostream>
#include <string>
#include <set>
#include <algorithm>
#include <ctime>
using namespace ::std;
using namespace std;

void main()
{
   multiset<string> buf;
   string linBuf;
   ifstream inFile("bible.txt");

   clock_t start=clock();
   while(getline(inFile,linBuf))
       buf.insert(linBuf);
   ofstream outFile("output.txt");
   copy(buf.begin(),buf.end(),ostream_iterator<string>(outFile,"\n"));
clock_t endt=clock();
   cout <<"Time for reading, sorting, writing: " << endt-start << "
ms\n";

import java.io.*;
import java.util.*;
public class IOSort
{
    public static void main(String[] arg) throws Exception
   {
            Collection<String> ar = new TreeSet<String> ();
            String line = "";
            BufferedReader in = new BufferedReader( new
FileReader("bible.txt"));
            PrintWriter out  = new PrintWriter(new BufferedWriter(new
FileWriter("output.txt")));
            long start = System.currentTimeMillis();
            while (true)
            { line = in.readLine();
              if (line == null)
                  break;
                ar.add(line);
            }
            int size = ar.size();
            for (String  c : ar)
            {
                out.println(c);
            }
            out.close();
            long end = System.currentTimeMillis();
           System.out.println("Time for reading, sorting, writing: "+
(end - start) + " ms");
   }

C++ is doing far worse now (the code used was multiset version)

Time for reading, sorting, writing: 2047 ms (java)
Time for reading, sorting, writing: 2016 ms (java)
Time for reading, sorting, writing: 2016 ms (java)
Time for reading, sorting, writing: 2015 ms (java)

and for c++

Time for reading, sorting, writing: 5281 ms (c++)
Time for reading, sorting, writing: 5703 ms (c++)
Time for reading, sorting, writing: 3921 ms (c++)
Time for reading, sorting, writing: 3718 ms (c++)