You could follow maven's standard project layout. You don't have to actually use maven, but it would make the transition easier in the future (if necessary). Plus, other developers will be used to seeing that layout, since many open source projects are layed out this way,

It depends on the build system in use for the project.

In the days of Ant or if you let the IDE set it up for you without specifying a build, it was mostly:

src/
bin/

Maven and Gradle use the Maven Standard Directory Layout ( https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html )

src
  main
    {lang}
      packages
    resources
  test
    {lang}
      packages
    resources

You can see that when using Gradle for groovy - https://docs.gradle.org/current/userguide/groovy_plugin.html#sec:groovy_project_layout the lang for the groovy sources is 'groovy'. This is important if you mix groovy, scala, kotlin, and java all in one project. For example (not my project, just one I found out there) https://github.com/bellingard/sample_multi-language-project

Folder-by-type only works on small-scale projects. Folder-by-feature is superior in the majority of cases.

Folder-by-type is ok when you only have a small number of files (under 10 per type, let's say). As soon as you get multiple components in your project, all with multiple files of the same type, it gets very hard to find the actual file you are looking for.

Therefore, folder-by-feature is better due to its scalability. However, if you use folder-by-feature, you end up losing information about the type of component a file represents (because it's no longer in a controller folder, let's say), so this too becomes confusing. There are 2 simple solutions for this.

First, you can abide by common naming conventions that imply its type in the file name. For example, John Papa's popular AngularJS style guide has the following:

Naming Guidelines

• Use consistent names for all components following a pattern that describes the component's feature then (optionally) its type. My recommended pattern is feature.type.js. There are 2 names for most assets:

  • the file name (avengers.controller.js)
  • the registered component name with Angular (AvengersController)

Second, you can combine folder-by-type and folder-by-feature styles into folder-by-feature-by-type:

com.example
├── pet
|   ├── Controllers
│   |   ├── PetController1.java
|   |   └── PetController2.java
|   └── Services
│       ├── PetService1.java
│       └── PetService2.java
├── user
|   ├── Controllers
│   |   ├── UserController1.java
│   |   └── UserController2.java
|   └── Services
│       ├── UserService1.java
│       └── UserService2.java

I would recommend to stick with default Maven layout ( and also use maven as build tool )

Productive classes / resources:

src/main/java
src/main/resources

Test data and classes:

src/test/java
src/test/resources

Maven can also take care to package your application properly with all the necessary jars ( look for maven assembly plugin )

Java has different class loaders to find the appropriate class. The default class loader (and most) use a folder structure as means to finding the class. You can also package up these into a Jar (Java Archive) file which is basically just a glorified zip file, and the files inside are just zipped in folders. The main reason for creating packages is to help avoid namespace collisions, two classes with the same name, and to help logically group and allow users of your code to find things better. Since the folder structure is solving a similar problem it was borrowed by the Java language. I discuss this a bit in the Java Data Structures - Packages (/library/java-data-structures/getting-there/packages) course. You might also want to dive a bit deeper using the Oracle Java SE tutorial (https://docs.oracle.com/javase/tutorial/java/package/packages.html) on packages. Hope it helps!