We Keep Coding

Convert a HashMap<Integer, Long> ito HashMap<Integer, Integer>

Collectors.counting() returns long values for each key in this method:
private static Map<Integer, Long> countDuplicates(HashSet<Card> cards) {
return cards.stream().collect(Collectors.groupingBy(Card::getRankNumber, Collectors.counting()));
}
Is there a way to cast or convert the resulting Map from Map<Integer, Long> to Map<Integer, Integer>?
Direct casting gives this exception:
Type mismatch: cannot convert from Map<Integer,Integer> to Map<Integer,Long>
Note: The implementation of my class guarantees that cards has five objects in it, so there is no chance of overflow.

Try the following:
private static Map<Integer, Integer> countDuplicates(HashSet<Card> cards) {
return cards.stream()
.collect(Collectors.groupingBy(Card::getRankNumber, Collectors.summingInt(x -> 1)));
}
Instead of Collectors.counting() use Collectors.summingInt(x -> 1) so that you get immediately the value as an Integer.

Another way to get Map<Integer, Integer> is to use toMap collector along with Integer::sum method reference as a merge function:
private static Map<Integer, Integer> countDuplicates(HashSet<Card> cards) {
return cards.stream()
.collect(Collectors.toMap(Card::getRankNumber, x -> 1, Integer::sum));
}

Both the Answer by dreamcrash and the Answer by Alex Rudenko seem correct. Here is example code I wrote to try both approaches.
The Card class.
package work.basil.example;
import java.util.Objects;
public class Card
{
public enum Suit
{
CLUB, DIAMOND, HEART, SPADE
}
// -------------| Member fields |-----------------------
private Suit suit;
private String name;
private Integer rankNumber;
// -------------| Constructors |-----------------------
public Card ( Suit suit , String name , Integer rankNumber )
{
Objects.requireNonNull( suit );
Objects.requireNonNull( name );
Objects.requireNonNull( rankNumber );
this.suit = suit;
this.name = name;
this.rankNumber = rankNumber;
}
// -------------| Getters |-----------------------
public String getName ( ) { return this.name; }
public Integer getRankNumber ( ) { return this.rankNumber; }
// -------------| Object methods |-----------------------
#Override
public String toString ( )
{
return "Card{ " +
"suit=" + suit +
" | name='" + name + '\'' +
" | rankNumber=" + rankNumber +
" }";
}
#Override
public boolean equals ( Object o )
{
if ( this == o ) return true;
if ( o == null || getClass() != o.getClass() ) return false;
Card card = ( Card ) o;
return suit == card.suit && getName().equals( card.getName() ) && getRankNumber().equals( card.getRankNumber() );
}
#Override
public int hashCode ( )
{
return Objects.hash( suit , getName() , getRankNumber() );
}
}
In Java 16 and later, we could reduce that Card class to a brief record. And in the code further down we would change getRankNumber to the implicit getter method rankNumber. The Suit enum would move to its own .java file.
package work.basil.example.cardgame;
public record Card( Suit suit , String name , Integer rankNumber )
{
}
The CastingStream class to collect those cards.
package work.basil.example;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
public class CastingStream
{
public static void main ( String[] args )
{
CastingStream app = new CastingStream();
app.demo();
}
private void demo ( )
{
Set < Card > cards = Set.of(
new Card( Card.Suit.HEART , "Ten" , 10 ) ,
new Card( Card.Suit.SPADE , "Ten" , 10 ) ,
new Card( Card.Suit.HEART , "Queen" , 12 )
);
// Code taken from Question. https://stackoverflow.com/q/65910153/642706
Map < Integer, Long > countDuplicatesLong =
cards
.stream()
.collect(
Collectors.groupingBy(
Card :: getRankNumber ,
Collectors.counting()
)
);
// Code taken from Answer by dreamcrash. https://stackoverflow.com/a/65910215/642706
Map < Integer, Integer > countDuplicatesIntegerBySummingInt =
cards
.stream()
.collect(
Collectors.groupingBy(
Card :: getRankNumber ,
Collectors.summingInt( x -> 1 )
)
);
// Code taken from Answer by Alex Rudenko. https://stackoverflow.com/a/65910400/642706
Map < Integer, Integer > countDuplicatesIntegerBySumMethodReference =
cards
.stream()
.collect(
Collectors.toMap( Card :: getRankNumber ,
x -> 1 ,
Integer :: sum
)
);
System.out.println( "cards = " + cards );
System.out.println( "countDuplicatesLong = " + countDuplicatesLong );
System.out.println( "countDuplicatesIntegerBySummingInt = " + countDuplicatesIntegerBySummingInt );
System.out.println( "countDuplicatesIntegerBySumMethodReference = " + countDuplicatesIntegerBySumMethodReference );
}
}
When run.
cards = [Card{ suit=HEART | name='Queen' | rankNumber=12 }, Card{ suit=HEART | name='Ten' | rankNumber=10 }, Card{ suit=SPADE | name='Ten' | rankNumber=10 }]
countDuplicatesLong = {10=2, 12=1}
countDuplicatesIntegerBySummingInt = {10=2, 12=1}
countDuplicatesIntegerBySumMethodReference = {10=2, 12=1}

In Java, how does one programmatically determine whether an `#Override` annotation is present in source code?

How does one programmatically determine whether an #Override annotation is present in Java source code? I have tried using method isAnnotationPresent.
public class A
{
int a = 1 ;
#Override
public String toString()
{ return "attribute a = " + a ; }
}
public class B extends A
{
int b = 2 ;
#Override
public String toString ()
{ return super.toString() + ", " + "attribute b = " + b ; }
}
import java.lang.reflect.Method ;
import java.lang.annotation.Annotation ;
public class Main
{
public static void main ( String [] args )
{
A a = new A() ;
B b = new B() ;
System.out.println ( a.toString() ) ;
System.out.println ( b.toString() ) ;
Class c = b.getClass() ;
Method m = null ;
try
{ m = c.getMethod("toString") ; }
catch ( Exception e )
{ System.exit(0) ; }
System.out.println ( "b's toString method is " + m ) ;
boolean bOverrides = m.isAnnotationPresent(Override.class) ;
System.out.println ( "bOverrides = " + bOverrides ) ;
}
}
Of course, the #Override annotation within the source code of class B could be omitted, and I'd like to know whether that annotation is, indeed, present in the Java source code or absent. Note that the output of main is:
bOverrides = false

Accordung to the docs for #Override, you can't. The retention policy is SOURCE, not RUNTIME, which means the annotation is not present at runtime.

Apply different equals for the same class

Suppose I have a Point class with fields x,y,z,name.
Objects of this class must be inserted in a Hash Set in two different ways depending on the user choice:
equals() checks equality of x,y,z fields
equals() checks equality of x,y,z,name fields
So I wonder what is the better way to organize such equals() redefinition on the fly during program execution?

You can create 2 Classes: Point and NamedPoint and override the equals() and hashcode() methods.
Here is an example in pseudo code:
class Point{
String name
int x,y,z
equals{
...
}
hashCode{
...
}
}
class NamedPoint extends Point{
equals{
}
hashCode{
}
}
Another option is to use one class, but add a new boolean switch, which changes the behavior of equals and hashCode.
P.S. I recommend you to read What issues should be considered when overriding equals and hashCode in Java?. You must be careful overriding these methods. It is useful to use the eclipse feature "Source --> Generate hashCode() and equals().." and after that to change the behavior of the generated methods.
P.S.2: Grigory Kalabin's link describes, what are the problems that might occure doing this.

If you can change from using HashSet to a TreeSet and add a custom comparator:
public class Point implements Comparable<Point> {
private double x;
private double y;
private double z;
private String name;
public Point( final double x, final double y, final double z, final String name ) {
setX( x );
setY( y );
setZ( z );
setName( name );
}
public boolean equals( final Point point ){
final boolean isEqual =
( this.getX() == point.getX()
&& this.getY() == point.getY()
&& this.getZ() == point.getZ() )
|| ( this.getName().equals( point.getName() ) );
// System.out.println( this.toString() + " == " + point.toString() + " = " + isEqual );
return isEqual;
}
/// #return the x
public double getX() { return x; }
/// #return the y
public double getY() { return y; }
/// #return the z
public double getZ() { return z; }
/// #return the name
public String getName() { return name; }
/// #param x the x to set
public void setX(final double x) { this.x = x; }
/// #param y the y to set
public void setY(final double y) { this.y = y; }
/// #param z the z to set
public void setZ(final double z) { this.z = z; }
/// #param name the name to set
public void setName(final String name) { this.name = name; }
public String toString() {
final StringBuffer str = new StringBuffer();
str.append( '(' );
str.append( getX() );
str.append( ',' );
str.append( getY() );
str.append( ',' );
str.append( getZ() );
str.append( ',' );
str.append( getName() );
str.append( ')' );
return str.toString();
}
public double distanceFromOriginSquared(){
return this.getX()*this.getX()
+ this.getY()*this.getY()
+ this.getZ()*this.getZ();
}
#Override
public int compareTo( final Point point ) {
if ( this.getName().equals( point.getName() ) )
return 0;
final double td = this.distanceFromOriginSquared();
final double pd = point.distanceFromOriginSquared();
if ( td < pd ) return -1;
if ( td > pd ) return +1;
if ( this.getX() < point.getX() ) return -1;
if ( this.getX() > point.getX() ) return +1;
if ( this.getY() < point.getY() ) return -1;
if ( this.getY() > point.getY() ) return +1;
return 0;
}
}
Running this:
public static void main( final String[] args ){
Point[] pts = {
new Point( 1, 1, 1, "1" ),
new Point( 2, 2, 2, "2" ),
new Point( 3, 3, 3, "3" ),
new Point( 1, 1, 1, "4" ),
new Point( 4, 4, 4, "2" )
};
TreeSet<Point> ps = new TreeSet<Point>();
for ( Point p : pts )
ps.add( p );
System.out.println( ps );
}
Gives an output of
[(1.0,1.0,1.0,1), (2.0,2.0,2.0,2), (3.0,3.0,3.0,3)]
So the last two values are not entered into the TreeSet as they are rejected by the comparator.

Java JTable: Setting a primary column to always sort by first

I'm using a JTable with say 3 columns, displaying information about files and folders:
Col1: Either "file" or "folder" (String)
Col2: Name of the file or folder (String)
Col3: Creation date (Timstamp)
I can easily sort the table by any column. But I'm not able to achieve the following desired behavior:
No matter what column header the user clicks, folders should always display before files. So basically sorting by Col1 in any order other than descending should not be possible. Also, if sorted by Col3, any folders should still display before files, regardless of their timestamp.
Any hint to how to do this is greatly appreciated.
Yours
Andreas

Try to use next code it helps you:
public class Example extends JFrame {
public Example() {
DefaultTableModel defaultTableModel = new DefaultTableModel(new Object[][]{{"1"},{"3"},{"2"}},new Object[]{"text"});
JTable t = new JTable(defaultTableModel);
TableRowSorter<TableModel> sorter = new TableRowSorter<TableModel>(defaultTableModel);
sorter.setComparator(0, new Comparator<Object>() {
#Override
public int compare(Object arg0, Object arg1) {
return arg0.toString().compareTo(arg1.toString());
}
});
t.setRowSorter(sorter);
add(new JScrollPane(t));
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pack();
setVisible(true);
}
public static void main(String...strings ){
Example e = new Example();
}
}
Here I set custom Comparator to TableRowSorter for column 0. You can compare your rows in different ways with your own Comparator implementation. Try it!
Comparator
RowSorter tutorial

Maybe this is a way to do it. There's probably a more elegant way to do it around.
The DefaultRowSorter Comparator only compares values for one column at a time, without additional information it alone can not make sure that one column in the set of columns (say column 1) must always be the first column to sort by.
If you mess with DefaultRowSorter.toggleSortOrder and add a new SortKey to keys at position 0 before setSortKeys gets called (this would be the primary column you always want to sort by first [column 1]), the ascending and descending arrows displayed in the column headers constantly mark column 1 (rightfully so), but this is not what the user expects if she clicks on column 2.
Another approach is to have Comparator know about column sort relationships. An easy way is to add information about sort precedences to the Objects for Comparator.compare. Simple precedences can be represented by a prefix String (for example: prefix "a" for column 1 and prefix "b" for all other columns).
PrefixedData can contain String, Boolean, Timestamp or null values and a prefix:
public class PrefixedData {
private String sData=null, prefix="";
private Timestamp tData=null;
private Boolean bData=null;
public void setData(String data) {
sData=data;
}
public void setData(Timestamp data) {
tData=data;
}
public void setData(boolean data) {
bData=data;
}
public void setPrefix(String prefix) {
this.prefix=prefix;
}
public String getPrefix() {
return prefix;
}
public Object getData() {
if(sData!=null) return sData;
if(tData!=null) return tData;
if(bData!=null) return bData;
return null;
}
}
JTable cells can be rendered like this for String, Boolean and Timestamp, if your table model returns PrefixedData for DefaultTableModel.getValueAt:
private static class PrefixedDataRenderer3 extends JLabel implements TableCellRenderer {
private static final SimpleDateFormat formatter = new SimpleDateFormat("MM.yyyy HH:mm:ss");
private static final JCheckBox box = new JCheckBox();
public PrefixedDataRenderer() {
setOpaque(true);
}
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
remove(box);
PrefixedData p=(PrefixedData) value;
if(p.getData()==null) return this;
if(p.getData().getClass().equals(String.class))
{
setText((String)p.getData());
return this;
}
if(p.getData().getClass().equals(Timestamp.class))
{
setText(formatter.format((Timestamp)p.getData()));
return this;
}
if(p.getData().getClass().equals(Boolean.class))
{
box.setSelected(((Boolean)p.getData()).booleanValue());
add(box);
}
return this;
}
}
And finally the Comparator can decide the order of things:
Comparator<Object> PrefixedDataComparator = new Comparator<Object>() {
private List<? extends SortKey> sortKeys;
#Override
public int compare(Object o1, Object o2) {
PrefixedData p1=(PrefixedData) o1;
PrefixedData p2=(PrefixedData) o2;
//First: compare prefixes (precedence data)
int prefixResult=p1.getPrefix().compareTo(p2.getPrefix());
sortKeys = tableOU.getRowSorter().getSortKeys();
//The prefixes are not the same, so return the result of the prefix comparision
//The result has to be inverted if we're sorting in descending order
//for the column the user has clicked
if(prefixResult!=0) return (sortKeys.get(0).getSortOrder().equals(SortOrder.ASCENDING) ? prefixResult : -prefixResult );
//Only if the prefixes are the same do we have to compare the payload data
//Try to impose an order for null
if(p1.getData()==null && p2.getData()!=null) return -1;
if(p1.getData()==null && p2.getData()==null) return 0;
if(p1.getData()!=null && p2.getData()==null) return 1;
//Objects compared are identical
if(p1.getData().equals(p2.getData())) return 0;
//Compare String
if(p1.getData().getClass().equals(String.class)) {
String s1=(String) p1.getData();
String s2=(String) p2.getData();
return s1.toLowerCase().compareTo(s2.toLowerCase());
}
//Compare Timestamp
if(p1.getData().getClass().equals(Timestamp.class)) {
Timestamp t1=(Timestamp) p1.getData();
Timestamp t2=(Timestamp) p2.getData();
if(t1.before(t2)) return -1;
if(t1.equals(t2)) return 0;
return 1;
}
//Compare Bool
if(p1.getData().getClass().equals(Boolean.class)) {
boolean b1=((Boolean)p1.getData()).booleanValue();
boolean b2=((Boolean)p2.getData()).booleanValue();
if(b1==false && b2==true) return -1;
if(b1==b2) return 0;
return 1;
}
return 0;
}
};
Any suggestions to this or different approaches a very welcome.

Well, the question is old but Google returned this page to me when I had a similar task. So, I'll post here my solution. Hope that it would help someone.
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.swing.DefaultRowSorter;
import javax.swing.JTable;
import javax.swing.RowSorter.SortKey;
import javax.swing.SortOrder;
import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;
import org.apache.log4j.Logger;
public class PredefinedRowSorter extends TableRowSorter< TableModel > {
private static final Logger LOGGER = Logger.getLogger( PredefinedRowSorter.class );
private static final SortKey EMPTY_ARRAY[] = new SortKey[ 0 ];
private final JTable table;
private SortKey preColumns[] = EMPTY_ARRAY;
private SortKey postColumns[] = EMPTY_ARRAY;
public PredefinedRowSorter( JTable table ) {
super( table.getModel() );
this.table = table;
}
private void check( SortKey modelColumns[], SortKey crossCheckColumns[], boolean post ) {
TableModel tm = table.getModel();
int max = tm.getColumnCount();
Set< Integer > used = new HashSet< Integer >();
for ( SortKey key : modelColumns ) {
if ( key == null )
throw new IllegalArgumentException( "SortKey must be non-null" );
if ( key.getColumn() < 0 )
throw new IllegalArgumentException( "SortKey column must be non-negative" );
if ( key.getColumn() >= max )
throw new IllegalArgumentException( "SortKey column is too high (out of model scope)" );
if ( key.getSortOrder() == SortOrder.UNSORTED )
throw new IllegalArgumentException( "SortKey must be ordered (ascending or descending)" );
if ( !used.add( key.getColumn() ) )
throw new IllegalArgumentException( "SortKey column must be unique (column " + key.getColumn() + " is repeating)" );
}
for ( SortKey key : crossCheckColumns )
if ( used.contains( key.getColumn() ) )
throw new IllegalArgumentException( "SortKey column must be unique (column " + key.getColumn() + " is already contained in " + ( post ? "post" : "pre" ) + " columns list)" );
}
public PredefinedRowSorter withPreColumns( SortKey... modelColumns ) {
if ( modelColumns == null )
modelColumns = EMPTY_ARRAY;
if ( !Arrays.equals( preColumns, modelColumns ) ) {
check( modelColumns, postColumns, true );
preColumns = modelColumns;
setSortKeys( getSortKeys() );
}
return this;
}
public PredefinedRowSorter withPostColumns( SortKey... modelColumns ) {
if ( modelColumns == null )
modelColumns = EMPTY_ARRAY;
if ( !Arrays.equals( postColumns, modelColumns ) ) {
check( modelColumns, preColumns, false );
postColumns = modelColumns;
setSortKeys( getSortKeys() );
}
return this;
}
public JTable getTable() {
return table;
}
public SortKey[] getPreColumns() {
return preColumns.length == 0 ? preColumns : preColumns.clone();
}
public SortKey[] getPostColumns() {
return postColumns.length == 0 ? postColumns : postColumns.clone();
}
private void setSortKeysInternal( List< ? extends SortKey > sortKeys ) {
try {
Field field = DefaultRowSorter.class.getDeclaredField( "sortKeys" );
boolean accessible = field.isAccessible();
if ( !accessible )
field.setAccessible( true );
field.set( this, sortKeys );
if ( !accessible )
field.setAccessible( false );
} catch ( IllegalAccessException e ) {
LOGGER.error( null, e );
} catch ( IllegalArgumentException e ) {
LOGGER.error( null, e );
} catch ( NoSuchFieldException e ) {
LOGGER.error( null, e );
} catch ( SecurityException e ) {
LOGGER.error( null, e );
}
}
private Object getViewToModelInternal() {
try {
Field field = DefaultRowSorter.class.getDeclaredField( "viewToModel" );
boolean accessible = field.isAccessible();
if ( !accessible )
field.setAccessible( true );
Object ret = field.get( this );
if ( !accessible )
field.setAccessible( false );
return ret;
} catch ( IllegalAccessException e ) {
LOGGER.error( null, e );
} catch ( IllegalArgumentException e ) {
LOGGER.error( null, e );
} catch ( NoSuchFieldException e ) {
LOGGER.error( null, e );
} catch ( SecurityException e ) {
LOGGER.error( null, e );
}
return null;
}
private void sortExistingDataInternal() {
try {
Method method = DefaultRowSorter.class.getDeclaredMethod( "sortExistingData" );
boolean accessible = method.isAccessible();
if ( !accessible )
method.setAccessible( true );
method.invoke( this );
if ( !accessible )
method.setAccessible( false );
} catch ( IllegalAccessException e ) {
LOGGER.error( null, e );
} catch ( IllegalArgumentException e ) {
LOGGER.error( null, e );
} catch ( NoSuchMethodException e ) {
LOGGER.error( null, e );
} catch ( InvocationTargetException e ) {
LOGGER.error( null, e );
LOGGER.error( null, ( ( InvocationTargetException )e ).getCause() );
}
}
#Override
public void setSortKeys( List< ? extends SortKey > sortKeys ) {
List< ? extends SortKey > oldSortKeys = getSortKeys();
List< ? extends SortKey > newSortKeys;
if ( sortKeys != null && !sortKeys.isEmpty() ) {
int max = getModelWrapper().getColumnCount();
for ( SortKey key : sortKeys )
if ( key == null || key.getColumn() < 0 || key.getColumn() >= max )
throw new IllegalArgumentException( "Invalid SortKey" );
newSortKeys = Collections.unmodifiableList( new ArrayList< SortKey >( sortKeys ) );
} else
newSortKeys = Collections.emptyList();
setSortKeysInternal( newSortKeys );
if ( !newSortKeys.equals( oldSortKeys ) ) {
fireSortOrderChanged();
boolean wasChanged = false;
if ( preColumns.length > 0 || postColumns.length > 0 ) {
List< SortKey > editableSortKeys = new ArrayList< SortKey >( newSortKeys );
for ( int i = preColumns.length - 1; i >= 0; i-- ) {
int modelColumn = preColumns[ i ].getColumn();
int idx = indexOfColumn( editableSortKeys, preColumns.length - i - 1, editableSortKeys.size(), modelColumn );
SortOrder sortOrder = idx < 0 ? preColumns[ i ].getSortOrder() : editableSortKeys.remove( idx ).getSortOrder();
editableSortKeys.add( 0, new SortKey( modelColumn, sortOrder ) );
}
int to = editableSortKeys.size();
for ( SortKey postColumn : postColumns ) {
int modelColumn = postColumn.getColumn();
int idx = indexOfColumn( editableSortKeys, preColumns.length, to, modelColumn );
SortOrder sortOrder;
if ( idx < 0 )
sortOrder = postColumn.getSortOrder();
else {
sortOrder = editableSortKeys.remove( idx ).getSortOrder();
to--;
}
editableSortKeys.add( new SortKey( modelColumn, sortOrder ) );
}
if ( wasChanged = !editableSortKeys.equals( newSortKeys ) )
setSortKeysInternal( editableSortKeys );
}
if ( getViewToModelInternal() == null )
sort();
else
sortExistingDataInternal();
if ( wasChanged )
setSortKeysInternal( newSortKeys );
}
}
private int indexOfColumn( List< SortKey > sortKeys, int fromIncl, int toExcl, int column ) {
for ( int i = toExcl - 1; i >= fromIncl; i-- )
if ( sortKeys.get( i ).getColumn() == column )
return i;
return -1;
}
};
Usage:
table.setRowSorter( new PredefinedRowSorter( table )
.withPreColumns( new SortKey( 0, SortOrder.ASCENDING ),
new SortKey( 1, SortOrder.ASCENDING ) ) );
This would set a preceding sorting on first two columns.
Post-sorting is available.
An end-user may sort these two columns too, thus switching the order of sorting (ascending/descending).
Also, this class is available as a part of JBroTable library (source code).
The principle of action is so: predefined columns are added to a sorting columns list before sorting and removed from this list after sorting. Adding and removal is performed via reflection because DefaultRowSorter implementation doesn't provide an access to the list.

didn't understand action listner of radio buttons

when i click adjacent two radio button then a line drawn between these button i put conditions in my code that line only will draw when two horizontal or vertical radio button selected else it show a error message ........... it works for me but if i click randomly two radio button it will throw an exception which i cant understand please give some discription about answer because i am beginner too............ and what is this means it shows when i compile prog..........Note: C:\Users\MUHAMMAD Umair\Desktop\ComponentLinkerTest.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.HashMap;
import java.util.Map;
import java.util.*;
/**
* #see http://stackoverflow.com/a/12389479/909085
*/
public class ComponentLinkerTest extends JComponent
{
// private Map<JComponent, JComponent> linked;
Map<JComponent, java.util.List<JComponent> > linked;// = new HashMap<>();
int n=1;
public ComponentLinkerTest ()
{
super ();
linked = new HashMap ();
}
static JRadioButton[] button = new JRadioButton[25];
public void gui()
{
setupLookAndFeel ();
JFrame frame = new JFrame ();
linker = new ComponentLinkerTest ();
frame.setGlassPane ( linker );
linker.setVisible ( true );
JPanel content = new JPanel ();
content.setLayout ( new GridLayout ( 5, 5, 5, 5 ) );
content.setBorder ( BorderFactory.createEmptyBorder ( 5, 5, 5, 5 ) );
frame.add ( content );
int i;
for (i = 0; i < 25; i++ )
{
// final JButton button = new JButton ( "Button" + i );
button[i] = new JRadioButton();
// panel.add(fontButtons[i]);
button[i].addActionListener ( new ActionListener ()
{
public void actionPerformed ( ActionEvent e )
{
link ((JRadioButton) e.getSource() );
}
} );
content.add ( button [i]);
}
frame.setDefaultCloseOperation ( JFrame.EXIT_ON_CLOSE );
frame.pack ();
frame.setLocationRelativeTo ( null );
frame.setVisible ( true );
}
/*public void link ( JComponent c1, JComponent c2 )
{
linked.put ( c1, c2 );
repaint ();
}*/
public void link ( JComponent c1, JComponent c2 )
{
if(linked.containsKey(c1)){
linked.get(c1).add(c2);
}else{
java.util.List<JComponent> list = new LinkedList<>();
list.add(c2);
linked.put ( c1, list );
}
repaint ();
}
/* protected void paintComponent ( Graphics g )
{
Graphics2D g2d = ( Graphics2D ) g;
g2d.setRenderingHint ( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
g2d.setPaint ( Color.BLACK );
for ( JComponent c1 : linked.keySet () )
{
Point p1 = getRectCenter ( getBoundsInWindow ( c1 ) );
Point p2 = getRectCenter ( getBoundsInWindow ( linked.get ( c1 ) ) );
/* Stroke stroke = new BasicStroke(8//,
/*BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0,
new float[] { 12, 12 }, 0);
g2d.setStroke(stroke);
g2d.setColor(Color.RED);
g2d.drawLine ( p1.x, p1.y, p2.x, p2.y );
}
}*/
#Override
protected void paintComponent ( Graphics g )
{
super.paintComponent(g);
Graphics2D g2d = ( Graphics2D ) g;
g2d.setRenderingHint ( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
g2d.setPaint ( Color.BLACK );
for ( JComponent c1 : linked.keySet () )
{
for(JComponent c2 : linked.get(c1)){
Point p1 = getRectCenter ( getBoundsInWindow ( c1 ) );
Point p2 = getRectCenter ( getBoundsInWindow ( c2 ) );
/* Stroke stroke = new BasicStroke(8//,
/*BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0,
new float[] { 12, 12 }, 0);
g2d.setStroke(stroke);*/
if(n==1)
{
g2d.setColor(Color.RED);
n=2;
}
else
{
g2d.setColor(Color.BLUE);
n=1;
}
g2d.drawLine ( p1.x, p1.y, p2.x, p2.y );
}
}
}
private Point getRectCenter ( Rectangle rect )
{
return new Point ( rect.x + rect.width / 2, rect.y + rect.height / 2 );
}
private Rectangle getBoundsInWindow ( Component component )
{
return getRelativeBounds ( component, getRootPaneAncestor ( component ) );
}
private Rectangle getRelativeBounds ( Component component, Component relativeTo )
{
return new Rectangle ( getRelativeLocation ( component, relativeTo ),
component.getSize () );
}
private Point getRelativeLocation ( Component component, Component relativeTo )
{
Point los = component.getLocationOnScreen ();
Point rt = relativeTo.getLocationOnScreen ();
return new Point ( los.x - rt.x, los.y - rt.y );
}
private JRootPane getRootPaneAncestor ( Component c )
{
for ( Container p = c.getParent (); p != null; p = p.getParent () )
{
if ( p instanceof JRootPane )
{
return ( JRootPane ) p;
}
}
return null;
}
public boolean contains ( int x, int y )
{
return false;
}
private static ComponentLinkerTest linker;
public static void main ( String[] args )
{
ComponentLinkerTest ct = new ComponentLinkerTest();
ct.gui();
}
private static JRadioButton last = null;
private static void link ( JRadioButton buton )
{
int a=0;
int i;
if ( last == null )
{
last = buton;
System.out.println(last.getX());
}
else
{
for( i=0 ;i<25 ;i++)
{
if(buton == button[i])
{
if(button[i-1] == last || button[i+1]==last || button[i-5] == last || button[i+5]==last)
{
System.out.println("in cond");
linker.link ( last, buton );
buton.setSelected(false);
last.setSelected(false);
last = null;
}
else
{
System.out.println("out cond");
buton.setSelected(false);
last.setSelected(false);
last = null;
JOptionPane.showMessageDialog(null,"Wrong position clicked ");
}
break;
}
else
{
System.out.println("button not found");
}
}
}
}
private static void setupLookAndFeel ()
{
try
{
UIManager.setLookAndFeel ( UIManager.getSystemLookAndFeelClassName () );
}
catch ( ClassNotFoundException e )
{
e.printStackTrace ();
}
catch ( InstantiationException e )
{
e.printStackTrace ();
}
catch ( IllegalAccessException e )
{
e.printStackTrace ();
}
catch ( UnsupportedLookAndFeelException e )
{
e.printStackTrace ();
}
}
}

You do no range checking...
This is going to cause an exception if you the last button is the on the last line, or the second button is one the first row
if (button[i - 1] == last || button[i + 1] == last || button[i - 5] == last || button[i + 5] == last)
You need to modify your checks to ensure that they don't extend below (0) or beyond (button.length - 1)...
if ((i > 0 && button[i - 1] == last) ||
(i < (button.length - 1) && button[i + 1] == last) ||
(i > 5 && button[i - 5] == last) ||
(i < (button.length - 1) && button[i - 5] == last)) {
Updated with alternative
Okay, that if statement was doing my head...so I took a different tact...
Basically, instead, I found the index of each button and calculated the distance that each button was from each other, they could only be 1 or 5 indices apart...
int lastIndex = indexOf(last);
int currentIndex = indexOf(buton);
int diff = Math.max(lastIndex, currentIndex) - Math.min(lastIndex, currentIndex);
if (diff == 1 || diff == 5) {
System.out.println("in cond");
linker.link(last, buton);
buton.setSelected(false);
last.setSelected(false);
last = null;
} else {
System.out.println("out cond");
buton.setSelected(false);
last.setSelected(false);
last = null;
JOptionPane.showMessageDialog(null, "Wrong position clicked ");
}
And the indexOf method...
protected static int indexOf(JRadioButton btn) {
int index = -1;
for (int value = 0; value < button.length; value++) {
if (button[value].equals(btn)) {
index = value;
break;
}
}
return index;
}
As a side note, I'd also beware of over using static. This suggest a bad design