implement SQL like select in Java

You can iterate over your "table" and check each item for the specified criteria. This will work with O(n) complexity. If you want to make your program faster create kind of indexes using Map (e.g. HashMap or TreeMap) (O(1)) or/and sort data and use binary search (log(n)).

Object serialization may work for you here...

public static void testSerialization() {
  String filename = "person.txt";
  StudentDetails s1 = new PersonDetails("hemanth", 10, "Male");
  StudentDetails s2 = new PersonDetails("bob", 12, "Male");
  StudentDetails s3 = new PersonDetails("Richa", 10, "Female");
  List list = new ArrayList();
  list.addAll(Arrays.asList(s1, s2, s3));
  FileOutputStream fos = null;
  ObjectOutputStream out = null;
  try {
    fos = new FileOutputStream(filename);
    out = new ObjectOutputStream(fos);
    out.writeObject(list);
    out.close();
    System.out.println("Object Persisted");
  } catch (IOException ex) {
    ex.printStackTrace();
  }
} 

Of course, reading will be very similar. Sadly, getting "select" queries on this is not trivial. I would suggest looking at the H2 database. It is trivially easy and works very well. Here is a small example that creates the database, a table, inserts stuff and reads it all out again.

public static void h2test() throws SQLException {
    JdbcDataSource ds = new JdbcDataSource();
    ds.setURL("jdbc:h2:testdb/somedb");

    Connection connection = ds.getConnection();
    PreparedStatement statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))");
    System.out.println(statement.execute());

    statement = connection.prepareStatement("INSERT INTO TEST VALUES(10, 'ten')");
    System.out.println(statement.executeUpdate());
    connection.commit();

    statement = connection.prepareStatement("SELECT * FROM TEST");
    ResultSet resultSet = statement.executeQuery();

    while (resultSet.next()) {
        System.out.println(resultSet.getInt(resultSet.findColumn("ID")) + ", " + resultSet.getString(resultSet.findColumn("NAME")));
    }
}

public static void main(String[] args) throws SQLException {
    System.out.println("Hello world");
    h2test();
}

I can really recommend it.

You can simply build multiple indexed views to satisfy the queries you want to resolve.

HashMap<String, List<Student>> studentsByClassId;
HashMap<String, List<SchoolClass>> classesByStudentId;

HashMap<String, Student> studentByStudentId;
HashMap<String, SchoolClass> classByClassId;

Maintain these in a single class which acts as your data access layer and provides lookup methods like you suggest. CRUD operations go through that class.

If you later wanted to switch to a database implementation, then the implementation of your data access class changes. But if you've done a reasonable job then it's interface won't.

I would like to suggest Guava. I don't have the full detail to give you a full example but in guava, you can create Predicates which will act as filters.

I love this tutorial that he did on guava, link to the url is here.

Just to give you an example of a possible use, you can specify a method to return a predicate for you like

public static Predicate<String> isStartsWith(final String input){
    return new Predicate<String>()
    {
        @Override
        public boolean apply( String str )
        {
            if(str.startsWith( input ))
                return true;
            return false;
        }
    };
}

and then call the method as such

filteredList.addAll( Collections2.filter( youList, isStartsWith("thing you want to filter") ) );

Have you considered using Hibernate? It allows you to use SQL-like queries (HQL) directly on Java objects. It's usually meant to be backed by a "real" database, but you don't have to. In fact, in one of my previous professional experiences, we used it with an in-memory database (HSQLDB) very successfully for that unique reason: being able to do complex queries (including aggregation, joining, etc.) on very large collections of java objects.