intellij idea full descargar java eclipse ide intellij-idea

java - full - intellij idea 2018 download



¿Cosas posibles en IntelliJ que no son posibles en Eclipse? (30)

He escuchado de personas que han cambiado en ambos sentidos y que juran por uno u otro.

Siendo un gran fan de Eclipse pero no teniendo tiempo para probar IntelliJ, estoy interesado en escuchar a los usuarios de IntelliJ que son "ex-eclipsianos" algunas cosas específicas que puedes hacer con IntelliJ que no puedes hacer con Eclipse.

Nota : Esta no es una pregunta subjetiva ni está destinada a convertirse en una guerra santa IDE. Por favor, anote las respuestas de cualquier persona .

CTRL-clic funciona en cualquier lugar

CTRL-click que lo lleva al lugar donde se define el objeto, funciona en todas partes, no solo en las clases y variables de Java en el código de Java, sino en la configuración de Spring (puede hacer clic en el nombre de la clase, la propiedad o el nombre del bean), puede hacer clic en el nombre de la propiedad o en la clase, o en el recurso incluido), puede navegar dentro de un clic desde la clase de Java hasta donde se utiliza como bean Spring o Hibernate; hacer clic en la etiqueta JSP o JSTL incluida también funciona, ctrl-click en la variable o función de JavaScript lo lleva al lugar donde está definido o muestra un menú si hay más de un lugar, incluidos otros archivos .js y código JS en HTML o JSP archivos.

Autocompletar para muchos idiomas.

Hibernar

Autocompletar en expresiones HSQL, en configuración de Hibernate (incluyendo nombres de columna de clase, propiedad y DB), en configuración de Spring

<property name="propName" ref="<hit CTRL-SPACE>"

y le mostrará una lista de esos frijoles que puede inyectar en esa propiedad.

Java

Autocompletar muy inteligente en código Java:

interface Person { String getName(); String getAddress(); int getAge(); } //--- Person p; String name = p.<CTRL-SHIFT-SPACE>

y muestra SOLAMENTE getName () , getAddress () y toString () (solo son compatibles por tipo) y getName () es el primero en la lista porque tiene un nombre más relevante. La última versión 8 que todavía está en EAP tiene aún más autocompletado inteligente.

interface Country{ } interface Address { String getStreetAddress(); String getZipCode(); Country getCountry(); } interface Person { String getName(); Address getAddress(); int getAge(); } //--- Person p; Country c = p.<CTRL-SHIFT-SPACE>

y lo autocompletará en silencio

Country c = p.getAddress().getCountry();

Javascript

Autocompletar inteligente en JavaScript.

function Person(name,address) { this.getName = function() { return name }; this.getAddress = function() { return address }; } Person.prototype.hello = function() { return "I''m " + this.getName() + " from " + this.get<CTRL-SPACE>; }

y muestra SÓLO getName () y getAddress () , sin importar cómo pueda obtener * los métodos que tiene en otros objetos JS en su proyecto, y ctrl-click en this.getName () lo lleva a donde está definido, incluso si Hay otras funciones de getName () en tu proyecto.

HTML

¿Mencioné autocompletar y hacer ctrl al hacer clic en rutas a archivos, como <script src = "", <img src = "", etc.?

Autocompletar en atributos de etiqueta HTML. Autocompletar en el atributo de estilo de las etiquetas HTML, tanto los nombres de atributos como los valores. Autocompletar en los atributos de clase también.
Escriba <div class = "<CTRL-SPACE> y le mostrará una lista de las clases de CSS definidas en su proyecto. Elija una, presione Ctrl y haga clic en ella y será redirigido a donde está definido.

Fácil resaltado lenguaje propio.

La última versión tiene inyección de idioma, por lo que puede declarar que su etiqueta JSTL personalizada generalmente contiene JavaScript y destacará JavaScript en su interior.

<ui:obfuscateJavaScript>function something(){...}</ui:obfuscateJavaScript>

Búsqueda indexada en todo el proyecto.

Puede usar Buscar usos de cualquier clase o método Java y encontrará dónde se usa, incluidas no solo las clases de Java, sino Hibernate, Spring, JSP y otros lugares. Renombrar Método refactorizar cambia el nombre del método no solo en las clases de Java, sino también en cualquier lugar, incluidos los comentarios (no se puede estar seguro de si la cadena en los comentarios es realmente el nombre del método, por lo que preguntará) Y solo encontrará su método incluso si hay métodos de otra clase con el mismo nombre. Una buena integración de control de origen (¿SVN admite listas de cambios? IDEA los respalda para cada control de origen), capacidad para crear un parche con sus cambios para que pueda enviar sus cambios a otros miembros del equipo sin confirmarlos.

Depurador mejorado

Cuando miro HashMap en la ventana de vigilancia del depurador, veo una vista lógica - claves y valores, la última vez que lo hice en Eclipse mostraba entradas con hash y campos siguientes - no estoy realmente depurando HashMap , solo quiero mirar es contenido

Validación de la configuración de Spring & Hibernate

Valida la configuración de Spring y Hibernate cuando lo editas, por lo que no necesito reiniciar el servidor para saber que escribí mal el nombre de la clase o agregé el parámetro del constructor, por lo que mi Spring cfg no es válida.

La última vez que lo intenté, no pude ejecutar Eclipse en Windows XP x64.

y te sugerirá person.name o person.address . Presione la tecla Ctrl y haga clic en person.name y lo llevará al método getName () de la clase Person .

Tipo Pattern.compile(""); ponga // allí, presione CTRL-SPACE y vea sugerencias útiles sobre lo que puede poner en su expresión regular. También puede utilizar la inyección de idioma aquí: defina su propio método que toma el parámetro de cadena, declare en el cuadro de diálogo de opciones de IntelliLang que su parámetro es una expresión regular, y también le dará autocompletado allí. No hace falta decir que resalta expresiones regulares incorrectas.

Otras características

Hay algunas características que no estoy seguro de que estén presentes en Eclipse o no. Pero al menos cada miembro de nuestro equipo que usa Eclipse, también usa alguna herramienta de fusión para fusionar cambios locales con cambios del control de origen, generalmente WinMerge. Nunca lo necesito, fusionarme en IDEA es suficiente para mí. Con 3 clics puedo ver la lista de versiones de archivos en el control de origen, con 3 clics más puedo comparar versiones anteriores o anteriores y actuales y posiblemente fusionar.

Permite especificar que necesito todos los .jars dentro de la carpeta WEB-INF/lib , sin seleccionar cada archivo por separado, por lo que cuando alguien ingresa un nuevo .jar en esa carpeta, lo selecciona automáticamente.

Lo mencionado anteriormente es probablemente el 10% de lo que hace. No uso Maven, Flex, Swing, EJB y muchas otras cosas, por lo que no puedo decir cómo les ayuda. Pero lo hace.

¡Intellij tiene un plug-in SVN muy superior a Subversive o Subclipse y funciona! La cantidad de tiempo que hemos perdido fusionando archivos de origen con Eclipse no merece la pena. Esto no es un problema con IntelliJ porque el complemento te ayuda mucho más.

Además, el complemento de Subclipse no es confiable: regularmente tenemos instancias en las que el complemento no cree que otros desarrolladores hayan registrado ningún código, pero sí lo ha hecho: ¡el servidor de CI los ha procesado!

Algunas otras cosas:

  • propagar parámetros / excepciones al cambiar la firma del método, muy útil para actualizar los métodos en el interior de la pila de llamadas
  • Validación de código SQL en las cadenas pasadas como argumentos a las llamadas jdbc (y todo el material de inyección de lenguaje recién empaquetado)
  • implementado en / sobrescrito en iconos para interfaces y clases (y sus métodos) y la navegación de implementación inteligente (Ctrl + Alt + Clic o Ctrl + Alt + B)
  • enlace entre las interfaces EJB 2.1 y las clases de bean (incluida la compatibilidad con refactorización); viejo, pero todavía inmensamente valioso cuando se trabaja en proyectos más antiguos

Búsqueda estructural y reemplazo.

Por ejemplo, busca algo como:

System.out.println($string$ + $expr$);

Donde $ string $ es un literal, y $ expr $ es una expresión de tipo my.package.and.Class, y luego se reemplaza por:

$expr$.inspect($string$);

Bueno, para mí son mil cosas pequeñas. Algunas de las macros, el diseño de GUI en general en Eclipse me parecen horribles. No puedo abrir múltiples proyectos en diferentes ventanas en Eclipse. Puedo abrir varios proyectos, pero luego el sistema basado en vistas intercambia un montón de cosas sobre mí cuando cambio archivos. Las inspecciones de código de IntelliJ parecen mejores. Su ayuda emergente para solucionar problemas comunes es agradable. Un montón de cosas simples de usabilidad como la barra lateral donde puedo desplazarme sobre un punto caliente y me dirá cada subclase de implementación de un método o el método que estoy implementando y desde dónde.

Siempre que he tenido que usar o ver a alguien usar Eclipse, parece que pueden hacer la mayoría de las cosas que puedo hacer en IntelliJ, pero tardan más tiempo y son más difíciles.

Dos cosas que IntelliJ hace que Eclipse no son muy valiosas para mí:

Separadores de métodos: esas débiles líneas grises entre métodos hacen que el código sea mucho más legible

Anti-aliasing de texto: hace que el código se vea tan bien en el IDE

El depurador IntelliJ tiene una característica muy útil llamada "Evaluar Expresión", que es mucho mejor que el colgante de eclipses. Tiene código completo y considero que generalmente es "más útil".

Hay muchas cosas que la idea resuelve de una manera mucho más simple, o no hay equivalente:

  • Acciones de autocompletar: haciendo ctrl + shift + a puede llamar a cualquier acción de idea desde el teclado sin recordar su combinación de teclas ... ¡Piense en gnome-do o launchy en windows, y ya tiene la idea! Además, esta función es compatible con las abreviaturas de CamelCasing;)

  • Estante: le permite separar fácilmente algunos fragmentos de código y luego revisarlos a través del visor de diferencias.

  • Historia local: está mucho mejor administrada y es más simple.

  • Anotaciones e historial de SVN: más sencillos de inspeccionar, y también puede ver fácilmente el historial solo para esa parte de un archivo fuente completo.

  • Autocompletar en todas partes, como las ventanas de evaluación de evaluación y condición de punto de interrupción.

  • Integración de Maven ... mucho, mucho más simple, y bien integrada.

  • Refactores mucho más cerca de la mano, como la inserción de bucles, ajuste / conversión, cambio de nombre y adición de variables.

  • Encuentra mucho poderoso y bien organizado. Incluso en grandes proyectos.

  • Mucho estable para trabajar con varias sucursales de un gran proyecto al mismo tiempo (como un antiguo corrector de errores de 1.5Gb por fuentes de sucursales, y la necesidad de trabajar en ellas simultáneamente, la idea demostró sus capacidades sólidas)

  • Una interfaz más limpia y simple ...

  • Y es más fácil de usar solo con el teclado, dejando de lado la necesidad de usar el mouse para muchas tareas simples, ahorrándole tiempo y prestándole más atención al código ... ¡donde sea más importante!

Y ahora, siendo OpenSource ... la base de usuarios de Idea crecerá exponencialmente.

IntelliJ tiene algunas inspecciones de código bastante avanzadas (comparables pero diferentes a FindBugs).

Aunque realmente me olvido de un complemento de FindBugs cuando uso IntelliJ (la integración de Eclipse / FindBugs es bastante buena).

Here hay una lista oficial de CodeInspections soportados por IntelliJ

EDITAR: Finalmente, hay un findbugs-plugin de findbugs-plugin para IntelliJ. Todavía es un poco beta, pero la combinación de inspecciones de código y FindBugs es simplemente increíble.

IntelliJ tiene soporte intellisense y refactoring de código en documentos jspx.

Intenté cambiar a IntelliJ debido al nuevo Android Studio. Pero ahora estoy muy decepcionado. Estoy usando Eclipse con el Complemento de los Recomendadores de Código . Aquí hay un ejemplo simple de por qué Eclipse es tan impresionante:

Quiero crear un nuevo SimpleTimeZone . SimpleTimeZone no tiene un constructor con cero argumentos.

Ctrl + Espacio en Eclipse

Ctrl + Espacio en IntelliJ

En IntelliJ no obtengo información sobre qué tipo de constructores tiene SimpleTimeZone .

Después de entrar en Eclipse

Obtengo el constructor seleccionado previamente lleno de nombres de variables predefinidos. Y puedo ver el tipo de cada argumento. Con Code Recomendanders, Eclipse adivina el constructor correcto por los tipos de variables definidos previamente en el alcance actual y llena el constructor con estas vars.

Después de entrar en IntelliJ no pasa nada. Tengo un constructor vacío. Tengo que presionar Ctrl + P para ver los argumentos esperados.

Introducir variable. ( Ctrl + Alt + V en Windows, Cmd + Alt + V en OSX)

Digamos que llama a un método, service.listAllPersons() Presione Ctrl + Alt + V e Ingrese , y se inserta la variable para devolver el valor de la llamada al método:

List<Person> list = service.listAllPersons();

Le ahorra escribir y no tiene que verificar el tipo de retorno del método que está llamando. Especialmente útil cuando se usan genéricos, por ejemplo

new ArrayList<String>()

[introducir variable]

ArrayList<String> stringArrayList = new ArrayList<String>();

(por supuesto, puede cambiar fácilmente el nombre de la variable antes de presionar Enter )

La idea 8.0 tiene el encantador ctrl + shift + espacio x 2 que realiza el siguiente autocompletar:

City city = customer.<ctrl-shift-space twice>

resuelve a

City city = customer.getAddress().getCity();

a través de cualquier número de niveles de getters / setters.

Lejos, mucho, mucho más refactorizaciones.

Mi atajo favorito en IntelliJ que no tiene equivalente en Eclipse (que he encontrado) se llama ''Ir al símbolo''. CTRL-ALT-SHIFT-N le permite comenzar a escribir y agrupar clases, nombres de métodos, nombres de variables, etc., desde todo el proyecto.

Mi tiempo puede ser un poco mal en términos de este hilo, pero solo tuve que responder.

Soy un gran fan del eclipse, usándolo desde su primera aparición. Un amigo me dijo entonces (hace más de 10 años) que sería un jugador. Él estaba en lo correcto.

¡Sin embargo! Acabo de comenzar a usar IntelliJ y si no ha visto o usado listas de cambios , se está perdiendo la programación del cielo.

La capacidad de rastrear mis archivos modificados (en mi rama de desarrollo y en clearcase) era algo que estaba buscando en un plugin para eclipse. Intellij rastrea todos sus cambios para un solo compromiso, extremadamente fácil. Puede aislar archivos modificados con listas personalizadas. Lo utilizo para los archivos de configuración que deben ser únicos a nivel local, pero se marcan constantemente cuando sincronizo o comparo con el repositorio; incluyéndolos en una lista de cambios, puedo monitorearlos, pero guardarlos cuidadosamente para poder concentrarme en las adiciones reales Estoy haciendo.

Además, hay un complemento de Commit Log que genera un texto de todos los cambios para aquellos SCCS que no están integrados con su software de seguimiento de errores. Al pegar el registro en el historial de trabajo de un ticket se capturan los archivos, su versión, fecha / hora y las etiquetas / rama. Es genial como el infierno.

Todo esto podría ser soportado a través de complementos (o futuras mejoras) en eclipse, apuesto; sin embargo, Intellij hace esto una brisa.

Finalmente, estoy realmente entusiasmado con el amor por este producto: las pulsaciones de teclado, por lo que es doloroso, pero divertido.

No olvides "comparar con el portapapeles".

Algo que uso todo el tiempo en IntelliJ y que no tiene equivalente en Eclipse.

Para mí, el soporte técnico de IDEA, especialmente en la versión 9 es insuperable. La sincronización sobre la marcha del proyecto con el modelo de Maven es simplemente fantástica y hace que el desarrollo sea agradable.

Probablemente no es una cuestión de qué se puede / no se puede hacer, sino cómo .

Por ejemplo, ambos tienen un editor rodeado de paneles de acoplamiento para proyecto, classpath, salida, estructura, etc. Pero en Idea, cuando empiezo a escribir todo esto, automáticamente, me permiten concentrarme en el código en sí. En el eclipse, todos estos paneles se mantienen abiertos, lo que deja el área de mi editor muy reducida, aproximadamente 1/5 del área total visible. Así que tengo que agarrar el mouse y hacer clic para minimizar en esos paneles. Hacer esto todo el día es una experiencia muy frustrante en el eclipse.

Exactamente lo contrario sucede con la ventana de salida de vista. En Idea, ejecutar un programa trae la ventana / panel de salida para ver la salida del programa, incluso si se minimizó por completo. En eclipse tengo que agarrar mi mouse nuevamente y buscar la pestaña de salida y hacer clic en ella para ver la salida de mi programa, porque la ventana / panel de salida es solo otra, como el resto de las ventanas, pero en Idea se trata en una forma especial: "Si el usuario desea ejecutar su programa, es muy probable que quiera ver la salida de ese programa". Parece tan natural cuando lo escribo, pero el eclipse falla en este concepto básico de interfaz de usuario.

Probablemente haya un atajo para esto en eclipse (ocultar automáticamente la ventana de salida al editar y mostrar automáticamente cuando se ejecuta el programa), pero como algunas otras decenas de características, el atajo debe buscarse en foros, ayuda en línea, etc., mientras que en Idea es un poco más " natural".

Esto se puede repetir para casi todas las características que ambos tienen, autocompletar, ajuste de palabras, vista rápida de documentación, todo. Creo que la experiencia del usuario es mucho más agradable en Idea que en Eclipse. Entonces el lema se hace realidad "Desarrollar con placer".

Eclipse maneja proyectos más grandes y más rápidos (+300 jars y +4000 clases) y creo que IntelliJ Idea 8 está trabajando en esto.

Todo esto, por supuesto, es subjetivo. ¿Cómo podemos medir la experiencia del usuario?

Si tiene el cursor en un método, presione CTRL + MAYÚS + I y aparecerá la implementación del método. Si el método es un método de interface , puede usar las flechas hacia arriba y hacia abajo para recorrer las implementaciones:

Map<String, Integer> m = ... m.contains|Key("Wibble");

Donde | es (por ejemplo) donde está su cursor.

Solo hay una razón por la que uso intellij y no eclipse: Usabilidad

Ya sea depuración, refactorización, autocompletado ... Intellij es mucho más fácil de usar con uniones de teclas consistentes, opciones disponibles donde las busca, etc. En cuanto a las características, será difícil para Intellij ponerse al día con Eclipse, ya que este último tiene muchos más complementos disponibles que intellij, y es fácilmente extensible.

Una característica muy útil es la capacidad de construir parcialmente un proyecto de reactor de Maven para que solo se incluyan las partes que necesita.

Para hacer esto un poco más claro, considere el caso de una colección de archivos WAR con una gran cantidad de recursos comunes (por ejemplo, JavaScript, archivos de configuración de Spring, etc.) que se comparten entre ellos utilizando la técnica de superposición . Si está trabajando en alguna página web (ejecutándose en Jetty) y desea cambiar parte del código de superposición que se guarda en un módulo separado, entonces normalmente esperaría que detuviera a Jetty, ejecute la compilación de Maven, inicie nuevamente Jetty y continuar. Este es el caso de Eclipse y casi todos los demás IDE con los que he trabajado. No es así en IntelliJ. Usando la configuración del proyecto, puede definir qué faceta de qué módulo desea incluir en una compilación de fondo. En consecuencia, terminas con un proceso que parece transparente. Realiza un cambio en casi cualquier código del proyecto y, al instante, está disponible después de actualizar el navegador.

Muy limpio, y muy rápido.

No podía imaginar codificar un extremo delantero en algo así como YUI respaldando en DWR / SpringMVC sin eso.

Una cosa que uso regularmente es establecer un punto de interrupción, pero luego controlar lo que hace. (En mi último trabajo, casi todos los demás usaron Eclipse ... Recuerdo que me sorprendió que nadie pudiera encontrar cómo hacerlo en Eclipse).

Por ejemplo, puede hacer que el punto de interrupción no se detenga realmente, sino que simplemente registre un mensaje en la consola. Lo que significa que no tengo que ensuciar mi código con "System.out.println (...)" y luego recompilarlo.

¡Hay una cosa que IntelliJ hace mucho mejor que Eclipse y que está vacía tus bolsillos!

Sin embargo, prefiero usarlo y una gran ventaja que tiene sobre Eclipce es la forma en que se sincroniza con el sistema de archivos, para grandes proyectos y computadoras lentas (sí, en los entornos de trabajo las PC son mucho más lentas que las de nuestro hogar) Eclipse parece lucha donde IntelliJ parece ser más rápido aunque con un tiempo de indexación inicial más lento.

La edición de la Comunidad de IntelliJ obviamente hace que el uso sea gratuito, pero pronto querrás esas refactorizaciones adicionales y pequeñas cosas agradables que no están incluidas en la edición de CC.

En mi opinión, generalmente es una mejor experiencia para el usuario pero si vale la pena el costo es una pregunta que cada desarrollador debe responder.

Pero vamos a estar agradecidos, tenemos hasta tres grandes IDE para Java ahora con NetBeans mejorando todo el tiempo.

Análisis de flujo de datos : análisis de flujo hacia atrás entre procedimientos y análisis de flujo hacia adelante, como se describe here . Mis experiencias se basan en Community Edition, que hace bastante bien el análisis de flujo de datos. Ha fallado (rechazado hacer cualquier cosa) en algunos casos cuando el código es muy complejo.

VIM emulador. Este complemento proporciona una emulación vi / vim / gvim casi completa al editar archivos en IDEA. La siguiente funcionalidad es compatible:

  • Teclas de movimiento
  • Borrar / Cambiar
  • Comandos de modo de inserción
  • Marcas
  • Registros
  • VIM deshacer / rehacer
  • Comandos de modo visual
  • Algunos comandos Ex
  • Algunos: establecer opciones
  • Expresiones regulares VIM completas para buscar y buscar / reemplazar
  • Macros
  • Diagramas
  • Historial de línea de comando
  • Buscar Historia
  • Listas de salto
  • Ayuda VIM

algunos comentarios sobre este complemento desde http://plugins.jetbrains.net/plugin/?id=164

No puedo ver volver a ningún otro id debido a este plugin ... Lo mejor de ambos mundos ... ¡Impresionante! eso es lo que me faltaba en todos los IDEs.

Algo que uso en IntelliJ todo el tiempo es refactorizar mientras escribo. He reescrito las clases de una impresión (originalmente escrita en eclipse) usando ambos IDE y utilicé aproximadamente un 40% menos de pulsaciones de teclas / clics del mouse para escribir las mismas clases en IntelliJ que en eclipse.

No me gustaría usar Eclipse hasta que admitan tanta refactorización con partes de código incompletas.

Aquí hay una lista más larga de características en IntelliJ 8.0 / 8.1 [ http://www.jetbrains.com/idea/features/index.html]

En primer lugar me encanta intellij. Hay al menos un centenar de características que tiene esa falta de eclipse. Estoy hablando de magnitudes mejores en cuanto a fiabilidad e inteligencia que ninguna hipérbole puede describir cuando se trata de refactorizar, renombrar, mover y otras que ya se han mencionado.

PERO, hay una cosa que intellij no permite que eclipse lo haga. No permite ejecutar varios proyectos a la vez bajo el mismo vm.

Cuando tiene proyectos separados para el frente, medio, núcleo, agentes, etc., donde todos tienen que interactuar entre sí, no puede modificar y depurar rápidamente al mismo tiempo. La única forma actual de hacer frente a esto es usar scripts ant para implementar y actualizar archivos jar en proyectos dependientes, o usar maven.

Eclipse permite la depuración de múltiples proyectos bajo una instancia de ide vm.

Preámbulo a mi respuesta: mi uso de Eclipse es limitado. Necesitábamos un IDE de Java para trabajar tanto en Windows como en Mac, y el puerto de Mac se ralentizó día a día. Esto fue hace años y estoy seguro de que ahora está bien. Pero eso es lo que nos llevó a cambiar a IntelliJ y estamos contentos con ello.

Ahora, para mi respuesta: una gran diferencia que no he visto mencionada todavía es que el soporte técnico es mejor con IntelliJ / Jet Brains. Enviamos un correo electrónico a JetBrains y recibimos una respuesta definitiva en menos de una hora. Buscar respuestas a los problemas de Eclipse da como resultado las respuestas habituales, "idiota estúpido" (por lo general, un pequeño número de respuestas) junto con un número mucho mayor de respuestas interesantes y útiles. Pero se necesita algo de clasificación para obtener la respuesta real.