Java pdf-pijltjepannotaties – volledige tutorial & best practices (2025)

Introductie

Heb je ooit moeite gehad om je team te laten focussen op specifieke secties van een PDF‑document tijdens beoordelingen? Je bent niet de enige. Of je nu technische documentatie, juridische contracten of projectspecificaties beheert, het aanwijzen van exacte gebieden voor discussie kan frustrerend zijn zonder de juiste tools.

Hier is de oplossing: Java PDF‑pijltjepannotaties met de GroupDocs.Annotation API. Deze krachtige aanpak stelt je in staat om programmatisch add arrow to pdf bestanden toe te voegen, waardoor samenwerking naadloos en professioneel wordt. Je kunt een proefversie verkrijgen via de GroupDocs tijdelijke‑licentiepagina.

Snelle antwoorden

  • Welke bibliotheek laat me add arrow to pdf toevoegen in Java? GroupDocs.Annotation for Java.
  • Heb ik een licentie nodig voor productie? Ja, een commerciële licentie verwijdert watermerken en ontgrendelt de volledige functionaliteit. Zie de GroupDocs pricing page voor details.
  • Welke Java‑versie wordt aanbevolen? JDK 11 biedt de beste prestaties en lange‑termijnondersteuning.
  • Kan ik meerdere pijlen toevoegen in één document? Absoluut – maak gewoon meerdere ArrowAnnotation‑objecten aan en voeg ze toe aan dezelfde Annotator.
  • Wordt batchverwerking ondersteund? Ja, je kunt door documenten itereren en dezelfde Annotator‑instantie hergebruiken na correcte vrijgave.

Wat is add arrow to pdf?

De add arrow to pdf‑operatie tekent een directionele marker op een PDF‑pagina om een specifiek gebied te markeren of erop te wijzen. Pijltjepannotaties worden opgeslagen als PDF‑objecten, zodat ze zichtbaar blijven in elke standaard‑conforme viewer en later bewerkt of beantwoord kunnen worden.

Waarom kiezen voor GroupDocs.Annotation voor Java PDF‑pijltjepannotaties?

GroupDocs.Annotation biedt een uitgebreide set annotatietypen, enterprise‑ondersteuning en een eenvoudige Java‑API die boilerplate‑code vermindert. Vergeleken met alternatieven verwerkt het 50+ invoer‑ en uitvoerformaten en kan het 500‑pagina‑PDF’s aan met minder dan 200 MB heap‑geheugen, dankzij de streaming‑architectuur.

Vereisten - wat je echt nodig hebt

Vereiste bibliotheken en afhankelijkheden

Voeg eerst de GroupDocs.Annotation Maven‑afhankelijkheid toe. Het fragment hieronder bevat de exacte coördinaten die je nodig hebt; vervang de versie‑placeholder door de nieuwste stabiele release.

<repositories>
   <repository>
      <id>repository.groupdocs.com</id>
      <name>GroupDocs Repository</name>
      <url>https://releases.groupdocs.com/annotation/java/</url>
   </repository>
</repositories>
<dependencies>
   <dependency>
      <groupId>com.groupdocs</groupId>
      <artifactId>groupdocs-annotation</artifactId>
      <version>25.2</version>
   </dependency>
</dependencies>

Pro tip: Controleer de GroupDocs releases‑pagina voor het meest recente versienummer. Nieuwe releases bevatten vaak prestatie‑patches en extra annotatiestijlen.

Omgevingsconfiguratie die geen hoofdpijn veroorzaakt

  • JDK 8 of hoger – JDK 11 wordt aanbevolen vanwege de verbeterde garbage‑collector en modulesysteem.
  • Maven 3.6+ – oudere Maven‑versies kunnen moeite hebben met transitieve afhankelijkheden.
  • IDE – IntelliJ IDEA of Eclipse bieden de beste debug‑ervaring voor Java‑bibliotheken.
  • Geheugen – Reserveer minstens 2 GB heap bij het werken met PDF’s groter dan 100 pagina’s.

Kennisvereisten (wees eerlijk tegen jezelf)

Je moet vertrouwd zijn met:

  • Core Java‑collecties en exception‑handling.
  • Maven‑afhankelijkheidsbeheer.
  • Basis bestands‑I/O (lezen en schrijven van binaire streams).

Als een van deze gebieden onzeker aanvoelt, overweeg dan een snelle opfrisser voordat je in de annotatiecode duikt.

GroupDocs.Annotation instellen - de juiste manier

Stap 1: Maven‑configuratie (met probleemoplossing)

Voeg de eerder getoonde repository en afhankelijkheid toe. Als Maven het artefact niet kan vinden, zorg er dan voor dat je de GroupDocs‑public‑repository hebt gedefinieerd in je pom.xml:

<properties>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
</properties>

Stap 2: Licentie‑instelling (kritisch voor productie)

Voor ontwikkeling kun je een tijdelijke proeflicentie gebruiken:

// For evaluation purposes
License license = new License();
// license.setLicense("path/to/license.lic"); // Comment this out for trial

Reality check: De proefversie voegt een zichtbaar watermerk toe aan elke opgeslagen PDF. Een productie‑licentie verwijdert dit watermerk en ontgrendelt de volledige annotatiefuncties.

Stap 3: Basisinitialisatie‑patroon

Annotator is de primaire klasse voor het laden van een PDF‑document en het toepassen van annotaties.
Omwikkel altijd de Annotator in een try‑finally‑blok zodat de onderliggende bronnen snel worden vrijgegeven:

Annotator annotator = null;
try {
    annotator = new Annotator("YOUR_DOCUMENT_DIRECTORY/input.pdf");
    // Your annotation code here
} finally {
    if (annotator != null) {
        annotator.dispose();
    }
}

Waarom het try‑finally‑blok? GroupDocs reserveert native geheugen voor PDF‑parsing; het niet vrijgeven van de Annotator kan leiden tot geheugenlekken, vooral bij het verwerken van veel documenten in een batch‑taak.

Complete implementatie‑gids - van nul tot productie

Begrijpen van pijltjepannotaties in context

Pijltjepannotaties fungeren als visuele aanwijzingen in document‑review‑workflows. Typische use‑cases omvatten:

  1. Review‑feedback – “Deze clausule behoeft verduidelijking.”
  2. Referentielink – “Zie het diagram op pagina 12.”
  3. Procesbegeleiding – “Start de audit hier.”
  4. Probleemmarkering – “Mogelijke typefout in deze alinea.”

Het ontwerpen van je annotatie‑UI rond deze scenario’s helpt gebruikers het hulpmiddel sneller te adopteren.

Stap 1: Annotatiereacties bouwen (de slimme manier)

Reacties veranderen een statische pijl in een interactief discussiepunt. De eerste keer dat je de Reply‑klasse noemt, definieer je deze beknopt:

Definition anchor: Reply vertegenwoordigt een tekstcommentaar gekoppeld aan een annotatie, met auteur‑informatie en tijdstempel.

Reply reply1 = new Reply();
reply1.setComment("First comment");
reply1.setRepliedOn(Calendar.getInstance().getTime());

Reply reply2 = new Reply();
reply2.setComment("Second comment");
reply2.setRepliedOn(Calendar.getInstance().getTime());

List<Reply> replies = new ArrayList<>();
replies.add(reply1);
replies.add(reply2);

Pro tip: Sla de gebruikers‑ID en rol op in de reply‑metadata; dit maakt het later eenvoudig om commentaren te filteren.

Stap 2: De pijltjepannotatie maken (met real‑world overwegingen)

Definition anchor: ArrowAnnotation is het GroupDocs‑object dat een directionele pijl rendert op een PDF‑pagina.

ArrowAnnotation arrow = new ArrowAnnotation();
arrow.setBox(new Rectangle(100, 100, 100, 100)); // Position and size
arrow.setCreatedOn(Calendar.getInstance().getTime()); // Creation time
arrow.setMessage("This is an arrow annotation"); // Annotation message
arrow.setOpacity(0.7); // Opacity level
arrow.setPageNumber(0); // Page number
arrow.setPenColor(65535); // ARGB pen color
arrow.setPenStyle(PenStyle.DOT); // Pen style
arrow.setPenWidth((byte) 3); // Arrow line width
arrow.setReplies(replies); // Attach replies

Belangrijke parameters uitgelegd:

  • Rechthoekcoördinaten – (x, y, width, height) waarbij (x, y) de linkerbovenhoek van de omhullende rechthoek is.
  • PenColor – Gebruikt een ARGB‑integer; 65535 levert een levendig blauw op. Gebruik een online converter voor aangepaste kleuren.
  • PenStyle – Opties omvatten DOT, DASH, SOLID, DASHDOT, DASHDOTDOT. Kies SOLID voor de meeste use‑cases.
  • Opacity – Variëert van 0.0 (transparant) tot 1.0 (ondoorzichtig). Een waarde van 0.7 balanceert zichtbaarheid en leesbaarheid van onderliggende inhoud.

Stap 3: Toevoegen en opslaan (met foutafhandeling)

Definition anchor: Annotator.save slaat alle wachtende annotatiewijzigingen op in het doel‑PDF‑bestand.

try {
    annotator.add(arrow);
    annotator.save("YOUR_OUTPUT_DIRECTORY/output.pdf");
    System.out.println("Arrow annotation added successfully!");
} catch (Exception e) {
    System.err.println("Failed to add annotation: " + e.getMessage());
    // Log the full stack trace in production
    e.printStackTrace();
} finally {
    annotator.dispose();
}

Vang altijd IOException en AnnotationException op om corrupte bestanden, ongeldige paden of permissie‑problemen af te handelen. Het loggen van de stack‑trace helpt je problemen in productie te diagnosticeren.

Veelvoorkomende valkuilen en hoe ze te vermijden

Probleem 1: Coördinaten komen niet overeen met de verwachte positie

Probleem: De pijl verschijnt verschoven ten opzichte van de beoogde plek.

Oplossing: De PDF‑coördinaten‑origin is linksonder, terwijl GroupDocs linksboven verwacht. Converteer je UI‑coördinaten dienovereenkomstig, of gebruik de ingebouwde convertToPdfCoordinates‑helper:

// If arrows appear in wrong positions, try adjusting the Y coordinate
int adjustedY = pageHeight - originalY - annotationHeight;
arrow.setBox(new Rectangle(x, adjustedY, width, height));

Probleem 2: Annotaties verdwijnen na opslaan

Probleem: Pijlen verschijnen tijdens verwerking maar ontbreken in de uiteindelijke PDF.

Oplossing: Dit duidt bijna altijd op een licentieprobleem. Controleer of het licentiebestand is geladen voordat een Annotator‑instantie wordt aangemaakt:

License license = new License();
try {
    license.setLicense("GroupDocs.Annotation.lic");
} catch (Exception e) {
    System.out.println("License not found, using trial mode");
}

Probleem 3: Geheugenlekken bij batchverwerking

Probleem: De JVM raakt zonder heap wanneer er tientallen PDF’s worden verwerkt.

Oplossing: Maak elke Annotator vrij nadat je klaar bent met een document, en verwerk bestanden in kleine batches om het geheugengebruik voorspelbaar te houden:

for (String documentPath : documentPaths) {
    Annotator annotator = null;
    try {
        annotator = new Annotator(documentPath);
        // Process document
    } finally {
        if (annotator != null) {
            annotator.dispose();
        }
    }
    
    // Force garbage collection every 10 documents
    if (processedCount % 10 == 0) {
        System.gc();
    }
}

Geavanceerde aanpassingstechnieken

Dynamische pijlpuntpositionering

Wanneer pijlen moeten volgen op gebruikersklikken in een web‑UI, bereken je de rechthoek aan de client‑kant en stuur je de coördinaten naar de backend. De backend kan dan een ArrowAnnotation instantiëren met die waarden.

public ArrowAnnotation createArrowAt(int x, int y, String message) {
    ArrowAnnotation arrow = new ArrowAnnotation();
    
    // Create arrow pointing to specific coordinates
    int arrowLength = 50;
    arrow.setBox(new Rectangle(x - arrowLength, y - arrowLength, arrowLength, arrowLength));
    arrow.setMessage(message);
    arrow.setOpacity(0.8);
    arrow.setPenColor(0xFF0000); // Red color
    arrow.setPenStyle(PenStyle.SOLID);
    arrow.setPenWidth((byte) 2);
    
    return arrow;
}

Stijlen van pijlen voor verschillende use‑cases

Je kunt PenColor en PenStyle variëren om betekenis over te brengen—bijv. rode gestippelde pijlen voor kritieke issues, groene solide pijlen voor goedgekeurde secties.

// Error highlighting (red, thick, solid)
public ArrowAnnotation createErrorArrow() {
    ArrowAnnotation arrow = new ArrowAnnotation();
    arrow.setPenColor(0xFF0000); // Red
    arrow.setPenWidth((byte) 4);
    arrow.setPenStyle(PenStyle.SOLID);
    arrow.setOpacity(0.9);
    return arrow;
}

// Suggestion arrows (blue, thin, dashed)
public ArrowAnnotation createSuggestionArrow() {
    ArrowAnnotation arrow = new ArrowAnnotation();
    arrow.setPenColor(0x0000FF); // Blue
    arrow.setPenWidth((byte) 2);
    arrow.setPenStyle(PenStyle.DASH);
    arrow.setOpacity(0.6);
    return arrow;
}

Real‑world implementatiescenario’s

Scenario 1: Document‑review‑systeem

In een multi‑user review‑portaal maakt elke reviewer een ArrowAnnotation aan en koppelt een Reply. Het systeem slaat replies op in een relationele database, waardoor een thread‑discussie per annotatie mogelijk is.

public class DocumentReviewSystem {
    public void addReviewArrow(String documentPath, int x, int y, 
                              String reviewComment, String reviewerName) {
        Annotator annotator = new Annotator(documentPath);
        
        ArrowAnnotation arrow = new ArrowAnnotation();
        arrow.setBox(new Rectangle(x, y, 50, 50));
        arrow.setMessage("Review by " + reviewerName);
        
        // Add reviewer's comment as reply
        Reply review = new Reply();
        review.setComment(reviewComment);
        review.setUser(new User(reviewerName));
        review.setRepliedOn(new Date());
        
        arrow.setReplies(Arrays.asList(review));
        
        annotator.add(arrow);
        annotator.save(documentPath.replace(".pdf", "_reviewed.pdf"));
        annotator.dispose();
    }
}

Scenario 2: Geautomatiseerde issue‑detectie

Een analyse‑engine scant PDF’s op compliance‑schendingen en voegt automatisch rode pijlen in die naar de problematische clausules wijzen.

public void highlightDetectedIssues(String documentPath, List<Issue> issues) {
    Annotator annotator = new Annotator(documentPath);
    
    for (Issue issue : issues) {
        ArrowAnnotation arrow = createArrowForIssue(issue);
        annotator.add(arrow);
    }
    
    annotator.save(documentPath.replace(".pdf", "_issues_highlighted.pdf"));
    annotator.dispose();
}

private ArrowAnnotation createArrowForIssue(Issue issue) {
    ArrowAnnotation arrow = new ArrowAnnotation();
    arrow.setBox(new Rectangle(issue.getX(), issue.getY(), 40, 40));
    arrow.setMessage("Issue detected: " + issue.getType());
    
    // Color‑code by severity
    switch (issue.getSeverity()) {
        case HIGH:
            arrow.setPenColor(0xFF0000); // Red
            break;
        case MEDIUM:
            arrow.setPenColor(0xFFA500); // Orange
            break;
        case LOW:
            arrow.setPenColor(0xFFFF00); // Yellow
            break;
    }
    
    return arrow;
}

Tips voor prestatie‑optimalisatie

Best practices voor geheugenbeheer

  • Gebruik try‑with‑resources (Java 7+) om Annotator‑objecten automatisch te sluiten:**

try (Annotator annotator = new Annotator(“document.pdf”)) { // Your annotation code } // Automatically disposed


- **Verwerk pagina’s individueel** in plaats van het volledige document in het geheugen te laden.  
- **Monitor heap‑gebruik** met tools zoals VisualVM of JConsole tijdens grootschalige batch‑runs.

### Overwegingen voor CPU‑prestaties

- Hergebruik een enkele `Color`‑instantie voor alle pijlen om onnodige objectallocatie te vermijden.  
- Vermijd geneste loops die herhaaldelijk identieke `PenStyle`‑objecten creëren.  
- Als je veel onafhankelijke PDF’s hebt, overweeg dan een thread‑pool, maar beperk het aantal gelijktijdige `Annotator`‑instanties om het geheugengebruik onder controle te houden.

## Probleemoplossingsgids – oplossingen voor echte problemen

### Probleem: Annotaties niet zichtbaar in Adobe Reader

**Symptomen**: Pijlen verschijnen in je aangepaste viewer maar niet in Adobe Acrobat.

**Oplossingen**:

1. Sla de PDF op met PDF/A‑1b‑compliance om maximale viewer‑compatibiliteit te garanderen:  

   ```java
// Try different save options if available
SaveOptions saveOptions = new SaveOptions();
saveOptions.setAnnotationType(AnnotationType.All);
annotator.save(outputPath, saveOptions);
  1. Controleer of de PDF‑versie minimaal 1.7 is; oudere versies kunnen nieuwere annotatietypen weglaten.

Probleem: Slechte prestaties met grote PDF’s

Symptomen: De applicatie loopt vast of wordt niet responsief bij het verwerken van PDF’s van meer dan 200 pagina’s.

Oplossingen:

  1. Verwerk pagina’s individueel in plaats van het hele bestand te laden:

// Process specific pages LoadOptions loadOptions = new LoadOptions(); loadOptions.setLoadCharts(false); // Skip charts if not needed Annotator annotator = new Annotator(documentPath, loadOptions);


2. **Schakel streaming in** in de `Annotator`‑constructor als je versie dit ondersteunt.  

3. Verhoog de JVM‑heap (`-Xmx4g`) voor zeer grote documenten.

### Probleem: Kleurweergave‑problemen

**Symptomen**: De pijl verschijnt grijs of volledig transparant.

**Oplossing**: Definieer de kleur met het ARGB‑formaat en zorg ervoor dat de kleurenspace van de PDF is ingesteld op **DeviceRGB**:

```java
// Use hex values for consistent colors
int red = 0xFFFF0000;    // ARGB format
int blue = 0xFF0000FF;
int green = 0xFF00FF00;

// Or convert from RGB
public int rgbToArgb(int r, int g, int b) {
    return (0xFF << 24) | (r << 16) | (g << 8) | b;
}

Testen van je implementatie

Unit‑testen van pijltjepannotaties

Een degelijke unit‑test laadt een voorbeeld‑PDF, voegt een ArrowAnnotation toe, slaat het bestand op, en opent het vervolgens opnieuw om het aantal annotaties en eigenschappen te verifiëren:

@Test
public void testArrowAnnotationCreation() {
    // Arrange
    String inputPath = "test-documents/sample.pdf";
    String outputPath = "test-output/annotated.pdf";
    
    // Act
    Annotator annotator = new Annotator(inputPath);
    ArrowAnnotation arrow = new ArrowAnnotation();
    arrow.setBox(new Rectangle(100, 100, 50, 50));
    arrow.setMessage("Test annotation");
    
    annotator.add(arrow);
    annotator.save(outputPath);
    annotator.dispose();
    
    // Assert
    assertTrue("Output file should exist", new File(outputPath).exists());
    
    // Verify annotation was added
    Annotator verifyAnnotator = new Annotator(outputPath);
    List<AnnotationInfo> annotations = verifyAnnotator.get();
    assertEquals("Should have one annotation", 1, annotations.size());
    verifyAnnotator.dispose();
}

Integratietesten

Voer dezelfde testsuite uit tegen PDF’s van verschillende groottes (10 pagina’s, 100 pagina’s, 500 pagina’s) en op verschillende viewers (Adobe Reader, Foxit, Chrome) om consistente weergave te garanderen.

Conclusie

Je hebt nu een volledige toolkit voor het implementeren van Java PDF‑pijltjepannotaties met GroupDocs.Annotation. Onthoud:

  • Maak Annotator‑objecten tijdig vrij.
  • Test met diverse PDF‑versies en -groottes.
  • Pas de prestatie‑tips toe bij opschalen naar batch‑taken.
  • Stijl pijlen zodat ze overeenkomen met de semantische betekenis van elk commentaar.

Volgende stappen: verken andere annotatietypen zoals TextAnnotation, AreaAnnotation en WatermarkAnnotation. Dezelfde initialisatie‑ en vrijgave‑patronen zijn van toepassing, zodat je een volledig uitgeruste document‑samenwerkingsplatform kunt bouwen.

Veelgestelde vragen

Q: Kan ik pijltjepannotaties toevoegen aan met wachtwoord beveiligde PDF’s?
A: Ja, geef het wachtwoord op bij het maken van de Annotator‑instantie:

LoadOptions loadOptions = new LoadOptions();
loadOptions.setPassword("your-password");
Annotator annotator = new Annotator("protected.pdf", loadOptions);

Q: Hoe verwerk ik meerdere documenten efficiënt in batch?
A: Verwerk documenten in kleine batches, hergebruik één Annotator per bestand, en roep dispose() aan na elke opslaan:

for (String doc : documents) {
    try (Annotator annotator = new Annotator(doc)) {
        // Add annotations
        annotator.save(doc.replace(".pdf", "_annotated.pdf"));
    }
    if (processedCount % 10 == 0) {
        System.gc(); // Encourage garbage collection
    }
}

Q: Wat is het maximale aantal annotaties per document?
A: GroupDocs legt geen harde limiet op, maar de praktische prestaties nemen af na ongeveer 1.000 annotaties op een 500‑pagina PDF tenzij je de eerder beschreven geheugen‑beheer‑technieken toepast.

Q: Kan ik pijlvormen aanpassen buiten de standaardopties?
A: De bibliotheek biedt standaard pijlpuntstijlen. Voor volledig aangepaste vormen kun je meerdere AreaAnnotation‑objecten combineren of overschakelen naar een grafisch‑gerichte bibliotheek die vectorpaden ondersteunt.

Q: Hoe ga ik om met verschillende PDF‑coördinatensystemen?
A: GroupDocs converteert automatisch tussen UI‑coördinaten linksboven en PDF‑coördinaten linksonder. Als je mismatches tegenkomt, controleer dan dubbel of je niet een extra transformatielaag aan de client‑kant toepast.

// Get page info for coordinate calculations
PageInfo pageInfo = annotator.getDocument().getPages().get(pageNumber);
int pageHeight = pageInfo.getHeight();

// Adjust Y coordinate if needed
int adjustedY = pageHeight - originalY;

Q: Wat zijn de licentiekosten voor productiegebruik?
A: GroupDocs biedt Developer-, Site- en OEM-licenties. Prijzen beginnen bij $699 per ontwikkelaar per jaar. Bezoek de GroupDocs pricing page voor de nieuwste cijfers.

Q: Hoe integreer ik dit met Spring Boot‑applicaties?
A: Maak een @Service‑bean die de annotatielogica encapsuleert, injecteer deze in je controllers, en exposeer een REST‑endpoint dat een PDF‑stream accepteert en de geannoteerde PDF teruggeeft.

@Service
public class AnnotationService {
    public void addArrowAnnotation(String inputPath, String outputPath, 
                                 int x, int y, String message) {
        try (Annotator annotator = new Annotator(inputPath)) {
            ArrowAnnotation arrow = new ArrowAnnotation();
            arrow.setBox(new Rectangle(x, y, 50, 50));
            arrow.setMessage(message);
            
            annotator.add(arrow);
            annotator.save(outputPath);
        }
    }
}

Q: Kan ik bestaande pijltjepannotaties uit PDF’s extraheren?
A: Ja, roep de getAnnotations()‑methode aan op een Annotator‑instantie en filter de resultaten op AnnotationType.Arrow.

Annotator annotator = new Annotator("document.pdf");
List<AnnotationInfo> annotations = annotator.get();

for (AnnotationInfo annotation : annotations) {
    if (annotation instanceof ArrowAnnotation) {
        ArrowAnnotation arrow = (ArrowAnnotation) annotation;
        System.out.println("Arrow message: " + arrow.getMessage());
    }
}

Aanvullende bronnen

Laatst bijgewerkt: 2026-08-14
Getest met: GroupDocs.Annotation 25.2 for Java
Auteur: GroupDocs

public void processBatch(List<String> documents, int batchSize) {
    for (int i = 0; i < documents.size(); i += batchSize) {
        List<String> batch = documents.subList(i, 
            Math.min(i + batchSize, documents.size()));
        
        processBatchInternal(batch);
        
        // Allow GC between batches
        System.gc();
        Thread.sleep(100);
    }
}

Runtime runtime = Runtime.getRuntime();
long memoryBefore = runtime.totalMemory() - runtime.freeMemory();

// Your annotation processing

long memoryAfter = runtime.totalMemory() - runtime.freeMemory();
System.out.println("Memory used: " + (memoryAfter - memoryBefore) + " bytes");

java -Xmx4g -jar your-application.jar

Gerelateerde tutorials