Develop Reference

How I run individual java file in IDEA?

I am a java beginner, the first java IDE I downloaded was Visual Studio Code, it was very easy to use and everything is auto configured. But it kind overheats my laptop all the time, so I want to try IDEA, so far it's a very good experience, except when I open a java file and tried to run it in IDEA, it always pops out this run configuration window and I don't understand how to configure it. In visual Studio Code I can open any java file any time and run without any issues, but now I have to go through creating projects every time. Is there any solution for this?

From how the file icon looks:
your file is not recognized as the part of the sources of your project. Check the project settings to ensure that source directories are correctly set.
I'd also recommend you to look up and follow the conventions for the directory structure of java projects.
Once you've fixed the problem with sources, you'll see "run" icon next to your class, main method, or when you're right clicking the file.

Command-line
To run a single file, there is no need for an IDE.
In Java 11 and later, the java tool at the command-line can both compile and execute a single-file Java class. See JEP 330: Launch Single-File Source-Code Programs.
If your class named HelloWorld were in a file named HelloWorld.java, on a console type:
java HelloWorld.java
To be clear: The java command-line tool really only executes Java apps, while the javac command-line tool compiles Java source code. As a convenience, the java tool was enhanced to effectively call javac on your behalf for a single-file.
JShell
If you just want to run a few lines of Java, try JShell, the REPL tool bundled with Java 9 and later.
See:
Java Shell User’s Guide by Oracle
JEP 222: jshell: The Java Shell (Read-Eval-Print Loop)
Search to learn more and find tutorials.
BlueJ
Using an IDE such as IntelliJ, NetBeans, or Eclipse can be a daunting task for the new student of Java. Those IDEs are heavy-duty tools designed for professional programmers.
I recommend using an IDE designed for beginners. BlueJ comes to mind, designed specifically for educational purposes. BlueJ makes getting started with Java easier.
If you insist on using IntelliJ, read on.
If using IntelliJ, define a project
IntelliJ is not designed to work with single files. IntelliJ expects you to work within a project.
I strongly recommend learning the basics of Maven to create and drive your new project. By defining your project in Maven, the configuration is independent of any one IDE. You can move your project between major IDEs such as IntelliJ, NetBeans, and Eclipse.
Maven is also very useful for downloading needed libraries ("dependencies") that you may want to leverage in your work. And Maven is good at packaging your Java app as a JAR (or WAR or EAR).
In IntelliJ, choose "New Project". In the New Project window, click the Maven item on left. Check the Create from archetype box. Scroll the list to find item for org.apache.maven.archetypes:maven-archetype-quickstart. Under that, choose the "RELEASE" item. Click Next button.
In Name field, enter something like MyFirstProject. Click Next button.
On the Maven settings page, just click Finish.
Wait a moment for IntelliJ to download some stuff and configure your project. Eventually you should see a BUILD SUCCESS message in the Run pane.
You will also see a pom.xml file displayed. The POM contains your settings for Maven to run your project, in XML format.
Change the <maven.compiler.source> and <maven.compiler.target> elements to the version of Java you are using. The current version is Java 17.
After editing the pom.xml, look for a little floating windoid with a tiny Maven icon. Click the icon to have Maven process your changed POM. Wait a moment.
In the Project pane, navigate to the App file. There you see code to print “Hello World!”. Let's run that code now. Click the green triangle button on the left, in the gutter, next to the main method line. A pop-up menu appears offering a Run item. Choose that item to run the app immediately.
Down in the Run pane, you should see the results, the Hello World! text.
At this point you can add your single file to the org.example package seen in the Project pane.
By the way, you can change that package name by context-clicking and choosing Refactor > Rename….
Later, learn to use the Run/debug configurations feature of IntelliJ.
Know that you need not create a new project for each time you want to do a little experiment. Create one project for such experiments. Keep adding new .java class files for each experiment. Delete old class files you no longer need.
Eventually, I suggest updating the versions of various items in your POM. The QuickStart archetype is not configured for the latest versions (for reasons I cannot fathom).
And when you learn about unit testing, replace JUnit 4 in the POM with JUnit Jupiter (Aggregator) to use JUnit 5. One of the benefits of using Maven is that you can easily switch out dependencies such as going from JUnit 4 to JUnit 5.

The IDE needs to know what's called the entry point of the program, i.e. where to start running your code. That's what the "Edit Configuration" window is wanting you to do.
If your file "Lab3.java" is in a package, make sure to fully specify that in the field you have in red. Otherwise without knowing how your project is structured (as the other answer alludes to), it's difficult to pinpoint what we're missing here.

When you create your IntelliJ project, add a directory /src right at the root of your project. Right click on that folder and tell IntelliJ that you wish to mark it as a source root. The directory should turn blue in color.
Put your packages under /src. IntelliJ will know that those are Java files.
When you want to run a class with a main method, choose Run->Edit Configurations. Tell IntelliJ that you want to add an Application. It should prompt you with the classes that have main methods in them. You'll have no trouble running them.

Use Maven or Graddle. Make sure the project is configured with the build tool enabled and integrated, it will do basic things automatically. If you are not sure, please create a new project and add your files in. Steps:
Open the IDE
New Project
Choose from the left side bar "Maven" or "Graddle"
Give it a name and the location in your machine.
Click Finish
Now you have the project ready. You need the appropriate method to run in java. A main class. In IntelliJ you can just type "main" and the auto-complete will add it for you, make sure you inside the curly brackets of the class {}. More info about the main class. You seem to have this nailed down.
Lastly make sure you have a JDK installed in the IDE. I am pretty sure this is your issue here, make sure to use one of the option IntelliJ provides. A full guide from the developers is here and should satisfy your needs. I would suggest OpenJDK for a beginner, because that served me well at the beginning, at the end of the day its your choice.

Right way of working Java Eclipse project with GIT

What's the right way of working with an Eclipse Java project with GIT?
I have the plugin EGIT installed and a simple java project. I did a commit/push of this java project by using the GIT bash console. I pushed only the source files.
Is that correct? Should I use Eclipse IDE somehow to make the init, commit and push? I couldn't find how to do this in Eclipse.
How should I retrieve the project from another machine? Should I use GIT console to retrieve the project or Eclipse?
I did the procedure in several ways, but they failed.

The generic answer is: whatever works for you, works.
We have a large git repository, and users with eclipse and intellij.
Some IDE users use specific plugins, such as Egit, others simply use the "default" support that most IDEs are shipped with. Such users simply go command line, or maybe, some other 3rd party tool.
Me, personally, I only rely on the IDE to show me the history of a file, or sometimes to quickly diff to revisions. Anything else I do on the command line.
From that point of view, as said: anything that works for you, works for you. You can use eclipse to manage the aspects of a git repository, but you don't have to.
Personally, I suggest to first get a good book on git, and to then extensively study the command line tooling. You also seem to be confused between the responsibilities of your IDE, and your source code management system.

Liferay Portlets Deployment

Good afternoon.
I'm working on a migration from WebSphere to Liferay 6.2 CE.
So far I am able to Export the main project to a WAR file, and Import it in Liferay.
The real problem comes on a development environment...
When changes are made to the project, the deployment process is time consuming.
It is necessary to exclude the previous portlet, and install the new one with the changes compiled.
Is there an easier way to deploy the project, directly has a Liferay Portlet?
Something like, click a button or run a command, and have it deployed immediately to Liferay's Server.
Best regards.

Build and Deployment Automation
Liferay 6.2 portlet development supports Ant, Ivy, and Maven build automation. Our developers typically use the Ant build scripts that come standard with Liferay 6.2, and we use Jenkins to automate our deployments to our various test and production servers.
However, even with the aforementioned tools, builds in 6.2 can be tedious and very time consuming. This issue is mostly eliminated in DXP with the introduction of OSGi modules but these OSGi modules are not supported in 6.2.
While Liferay does not provide a solution for this out-of-the-box there is one tool above all else that has drastically decreased our build and deployment times in 6.2
JRebel
JRebel is a fabulous product for Java EE development and has been especially helpful and supported on the Liferay platform. Essentially JRebel is a tool that allows you to save changes to your code and see those changes instantly without running any Ant targets or moving any war files around.
JRebel is not a free product (it costs $500 a year per license) but you can get a free copy (with 100% of the functionality) if you are using for non-commercial projects. To get a license simply search for "My JRebel" and register an account.
JRebel for Liferay
JRebel integrates very easily with Liferay, and there is some documentation on the Liferay Blogs regarding configuration. However the last time I checked the blog posts outline an older way of configuration that is no longer supported (or at least no preferred). Therefore I will briefly go over the steps needed to configure JRebel with Liferay.
Configuration
Follow these steps after you have obtained either a free license through My JRebel or purchased a license key if this is a commercial project. If you are onboarding this tool at your company you will definitely want to use their license server.
Open your Liferay Development Studio (or Eclipse IDE with the Liferay plugin installed) and go to Help > Eclipse marketplace.
Once the Eclipse Marketplace window loads search for JRebel and go through the download and installation process.
Once the installation process is complete (and your IDE has restarted), go to Help > JRebel > Activation.
You will have a window with three options (activation code, license key, license server). If you are using My JRebel you will likely have a .lic file. You will want to select that option and locate the file on your system. If you are using this in an enterprise setting I highly suggest using a license server. If have not included directions for that as it is outlined elsewhere and is not at all specific to Liferay.
Once JRebel is activated you should now see a JRebel configuration perspective in the top right hand corner
Click on the perspective, navigate to the start up tab, and select the following configurations
Then navigate to the projects tabs and select all the portlets you want to apply JRebel to. Only select the first box unless you are running some type of container environment (which you did not specify).
Then in your Eclipse menu select Project > Build Automatically
Testing your configuration
There are a few indications that your configuration is working. Firstly, in your projects source folder you should see a rebel.xml configuration file.
If you see the file there it's time to start the server. Immediately after starting the server you will some new lines written at the top of the catalina log file.
Additionally in your Tomcat's temp folder you should see a new JRebel directory.
Once the portal loads make a change to one of your Java files. In the Catalina console you should see a newly printed line with the fully qualified name of the class you just modified. Check to see if your change has taken effect!
Issues
If you have issues at any part in this process there are a few things you might want to look out for. If you are receiving any permgen errors you might want to modify the JVM flags related to memory in your server configuration panel. Additionally in the same location you may need to toggle the publish automatically settings. Additionally I have always had issues with JRebel not working for made to method signatures in the ORM files generated by service builder. If I am adding a new method to those classes JRebel doesn't pick it up. If I am adding or modifying the type of a parameter in one of the methods in those classes JRebel doesn't pick it up. Changes to the code in the localserviceimpl and serviceimpls seems fine in all other regards, and every other class works fine with JRebel. The engineers at ZeroTurnAround swear it works perfectly with Service Builder, but I haven't had success in those aforementioned cases.

How to optionally open last intellij project (or not) on startup?

I have just read this question:
Stop intellij opening projects on startup
Ideally, I would like to have 2 intellij icons on my desktop - one which opens the last project and one which doesn't.
In other words, I would like the flexibility of both functions.
Perhaps intellij has some command-line argument that specify which "mode" I desire on startup?
I'd rather not have to fire up an editor and edit the xml each time I start up IntelliJ.

File --> Settings --> Appearance '&' Behavior --> System Settings.
CLICK on System Settings, not a sub-tab, and uncheck the box that says "Reopen last project on startup."
As far as separate projects are concerned you could, perhaps, make a shortcut to the IML or intellij project file in it's respective directory to your desktop and use that. This way you could link as many projects as you'd like, though passing arguments to the intellij exe is also viable it may be a bit impractical. A plugin would most likely be best to automate that process, but I don't know the technicalities so take these tips with a few grains of salt.
EDIT: I also think it's worth mentioning that intellij's settings, as is the spirit of java, has pretty close to uniform and connected preferences accross platforms whether windows or linux or mac, but extending features have to be made compatable to the specific platform if it utilizes a native function (like passing parameters to an exe in windows or doing the same with an shell script in linux.)

Hints to improve Eclipse performance

Working in Eclipse with big projects can be painful because of IDE works slowly, sometimes stops and doesn't respond. I know it can depends on OS, version of Eclipse etc.
All eclipse developers have tricks which tuning workspace in Eclipse, What should be turn off to improve performance the IDE?
For example: My project has the recommendation to turn off xml validations, don't install m2eclipse.
Because of eclipse's performance some devs use IntelliJ.
UPDATED:
For these who feel uncomfortable with the eclipse's performance I suggest to try other solutions just to have comparison - I tried and this was the best what I've done in performance subject :)

Remove unwanted activation of some of the plugins at start-up by going to windows-->preference-->General-->Startup and shutdown.
Also make sure you don't use those plugins in any of your views
Eclipse is not a word processor. Better to disable the spell check. Disabling spell check will reduce the eclipse burden by going to Windows-->Preference-->General-->Editors
--> Text Editors-->Spelling
When eclipse builds the project, it will delete all output folders and rebuild classes built by other compilers. We can disable such features, as deleting the output folders and rebuilding will take sometime. Goto Windows-->Preference-->Java-->Compiler-->Building
Disabling label decorations which is of less use for you, will also help you to gain some performance . Goto Windows-->Preference-->General-->Appearance-->Label
Decorations
Close unwanted projects and use working set option to move from one group of
project to another smoothly.
You could also disable Eclipse automatic building, if it is not needed for you.
Goto Project-->Build Automatically (uncheck it)
Do not keep lot of tabs opened in the editor. Better to have around 20 tabs .
Regularly close the unused tabs. To open resource we can always use ctrl+shift+R and
ctrl+shift+T (java resource) instead of opening lot of tabs
Disable unwanted plugins. Full J2EE eclipse version has an option to disable/uninstall plugins. Goto Help-->Software Updates-->Manage Configuration. Right click on any installed plugin to get disable option. If this option is not available then enable Classic Update by going to Windows-->Preference-->Capabilty and check classic update. Now the manage configuration option should be available in help menu

I'm an intelliJ user though occasionally peep into eclipse since I like to use it. Couple of things you can try which my work colleague pointed to are
Show the heap status (General -> Show heap status) can keep an eye on memory and hit the button to clear!
In project properties set the default output folder to be outside of the target
Workspace options, unchecking build automatically (build in the background as soon as you hit Save (Ctrl+S)), refresh automatically & save auto before build. You may have you own preferences but can give it a try.
Show sleeping/hidden tasks to see whats going on underneath?
You must have already tried giving it more memory I guess. Hopefully it will improve.

Ensure you have enough memory and that Eclipse is actually using it (add -Xms -Xmx arguments at Eclipse start).
Remove all plug-ins, you dont use.
Create separate workspace for projects you change rarely and include them as JARs to your primary project.
Use debug mode only when you are debugging (it is slower and uses more memory).

Put all validators (preferences > Validation) to 'Manual' and deselect 'Build'.
Also, consider using an external svn client (like Tortoise) instead of an eclipse plugin like subclipse:
Subclipse consumes so much system resources and effects eclipse performance greedily in big projects. If you could, consider not to use subclipse especially in projects that contain thousands of code kept in subversion source repository. It's really become a very heavy-weight plug-in with heavy-weight code.

Add the source and output directory trees to your Virus Scanner's exclusion list.

1.Disable unecessary validations and startup action in eclipse reference.
For validations: on eclipse menu Windows -> Preferences -> Validation, click “Disable All”, and then select the validator which you need. I selected “Classpath Dependency Validator” only.
For startup action: on eclipse menu Windows -> Preferences, type “startup”, select “Startup and Shutdown”, untick the options you don’t need.
2.Modify eclipse.ini(set the Xmn(new generation size), Xms and Xmx, enable parallel GC)
Change or add the following settings given below
-Xmn128m
-Xms1024m
-Xmx1024m
-Xss2m
-XX:PermSize=128m
-XX:MaxPermSize=128m
-XX:+UseParallelGC

If you have a lot of projects open, it might help to close unused projects. It helps a lot, as Eclipse does not have to provide all the memory model required for content assist.

Disable 'Build Automatically' in the Project menu and set up a key binding for Build Project instead, e.g. CTRL + B. I've tried so many different things to improve Eclipse performance, but this is the only one that really works for me.

Getting slow performance usually is a problem of one or more badly implemented plugins. Identifying the bad plugin and uninstalling it normally removes the bad performance (of course if you realy NEED the plugin you are out of luck ;) ).

I am debugging a large program containing lots of breakpoints. I have heavily increased Eclipse's performance while debugging by disabling the breakpoints at startup, and only enabling them again just before I need them.