We Keep Coding

ClassCastException while using generics in java

I am new to java programming and I am learning generics.I tried to do some generics program by myself and I am getting Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Lcom.ashwin.model.Car;.
I have a Vehicle Class:
public class Vehicle {
private int id;
private String name;
private String color;
private int plateNo;
//omitted getters and setters
}
I have a Car class extending Vehicle Class.
public class Car extends Vehicle {
public Car(int id, String name, String color, int plateNo) {
super.setId(id);
super.setColor(color);
super.setPlateNo(plateNo);
}
}
I have CarDAOImpl.java class:
public class CarDAOImpl implements VehicleDAO<Car> {
private static ParkingLot<Car> park=new ParkingLot<Car>(10);
#Override
public boolean insert(Car v) {
if(park.getSpace()==-1) {
return false;
}
else {
park.setSpace(park.getSpace()-1);
park.setVehicle(v);
return true;
}
}
#Override
public boolean delete(Car k) {
if(park.getSpace()==10) {
return false;
}
else {
boolean result=park.deleteVehicle(k);
return result;
}
}
#Override
public Car[] getAll() {
return park.getVehicle();
}
}
I have another ParkingLot.java class:
public class ParkingLot<T> {
private int space;
private T[] vehicle;
public ParkingLot() {
}
public ParkingLot(int sp) {
this.vehicle=(T[])new Object[sp];
this.space=sp;
}
public int getSpace() {
return space;
}
public void setSpace(int space) {
this.space = space;
}
public T[] getVehicle() {
return vehicle;
}
public void setVehicle(T vehicle) {
this.vehicle[space]=vehicle;
}
public <T extends Vehicle> boolean deleteVehicle(T v) {
for(int i=0;i<vehicle.length;i++) {
if(((Vehicle) vehicle[i]).getId()==v.getId()) {
vehicle[i]=null;
return true;
}
}
return false;
}
}
My main method is:
public class Main {
public static void main(String[] args) {
VehicleDAO<Car> v=new CarDAOImpl();
boolean inserted=v.insert(new Car(1,"ford","Red",1234));
System.out.println(inserted);
Car[] c=v.getAll();
for(int i=0;i<c.length;i++)
{
System.out.println(c[i]);
}
}
}
I am getting error at this line of CarDAOImpl.java class:
#Override
public Car[] getAll() {
return park.getVehicle();
}
The exception is:
Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Lcom.ashwin.model.Car;

You need to update your constructor to include the class object as a parameter:
public ParkingLot(Class<T> clazz, int sp) {
this.vehicle= (T[]) Array.newInstance(clazz, sp);
this.space=sp;
}
And your variable declaration should look like this:
private static ParkingLot<Car> park = new ParkingLot<>(Car.class, 10);

How print the entire data structure created with Composite?

I have class-Composite:
public class CompositeText implements ComponentText {
private TypeComponent type;
private String value;
private final List<ComponentText> childComponents;
private CompositeText() {
childComponents = new ArrayList<>();
}
public CompositeText(String value, TypeComponent typeComponent) {
this.value = value;
this.type = typeComponent;
childComponents = new ArrayList<>();
}
#Override
public void add(ComponentText componentText) {
childComponents.add(componentText);
}
#Override
public void remove(ComponentText componentText) {
childComponents.remove(componentText);
}
#Override
public TypeComponent getComponentType() {
return this.type;
}
#Override
public ComponentText getChild(int index) {
return childComponents.get(index);
}
#Override
public int getCountChildElements() {
return childComponents.size();
}
#Override
public int getCountAllElements() {
return childComponents.stream()
.mapToInt(ComponentText::getCountAllElements)
.sum();
}
#Override
public String toString() {
return null;
}
}
I created classes that perform the same action - parsing, parsing text into paragraphs, into sentences, into tokens, into symbols.
public class IntoParagraphParser implements ActionParser {
// call IntoSentenceParser
}
public class IntoSentenceParser implements ActionParser {
// call IntoLexemeParser
}
public class IntoLexemeParser implements ActionParser {
// call IntoSymbolParser
}
public class IntoSymbolParser implements ActionParser {
}
All data is stored in List <ComponentText> childComponents in class-Composite - CompositeText.
How to properly create a method so that it prints all the data that is inside the composite?
I think this will be the method toString() in CompositeText.
Class IntoParagraphParser look:
public class IntoParagraphParser implements ActionParser {
private static final String PARAGRAPH_SPLIT_REGEX = "(?m)(?=^\\s{4})";
private static final IntoParagraphParser paragraphParser = new IntoParagraphParser();
private static final IntoSentenceParser sentenceParser = IntoSentenceParser.getInstance();
private IntoParagraphParser() {
}
public static IntoParagraphParser getInstance() {
return paragraphParser;
}
public ComponentText parse(String text) throws TextException {
ComponentText oneParagraph;
ComponentText componentParagraph = new CompositeText(text, TypeComponent.PARAGRAPH);
String[] arrayParagraph = text.split(PARAGRAPH_SPLIT_REGEX);
for(String element: arrayParagraph) {
oneParagraph = new CompositeText(element, TypeComponent.PARAGRAPH);
oneParagraph.add(sentenceParser.parse(element));
componentParagraph.add(oneParagraph);
}
return componentParagraph;
}
}

Need #Override the method toString() in CompositeText like this:
#Override
public String toString() {
StringBuilder builder = new StringBuilder();
for (ComponentText component : childComponents) {
builder.append(component.toString());
}
return builder.toString();
}
But how to write this code correctly with Stream API?
#Override
public String toString() {
StringBuilder builder = new StringBuilder();
childComponents.stream().map(...????
return builder.toString();
}

Java generics self bounded types

Consider the below example, what is a good way to avoid the warning with respect to unchecked conversion below?
Usercase is as
An interface which represent a generic statemachine
Each statemachine implementation requires a service, a set of utils required while running corresponding statemachines.
A default service which provides common services across statemachines
A transaction(txn) a binder of state and service.
import java.util.function.Consumer;
public class GenericsTest {
public static void main(String[] args) {
AService service = new AService("Aservice");
new Txn<>(service).next();
new Txn<>(new DefaultState()).next();
}
}
// ----------------------------------------------------------- //
interface Service {
String getName();
<T extends Service> State<T> getState();// this is unclear how to use generics here
}
interface State<T extends Service> {
Consumer<Txn<T>> getFunction();
int getN();
}
// ----------------------------------------------------------- //
class Txn<T extends Service> {
private T service;
private State<T> current;
Txn(State<T> current) {
this.current = current;
}
Txn(T service) {
this.service = service;
this.current = this.service.getState();
}
int next() {
do {
current.getFunction().accept(this);
} while (current.getN()>0);
return current.getN();
}
public State<T> getCurrent() {
return current;
}
public void setCurrent(State<T> current) {
this.current = current;
}
}
// ----------------------------------------------------------- //
abstract class DefaultService implements Service {
private String name;
public DefaultService(String name) {
this.name = name;
}
public String getName(){
return this.name.toUpperCase();
}
}
class AService extends DefaultService implements Service {
public AService(String name) {
super(name);
}
#Override
public State<AService> getState() {
return new AState(6);
}
}
// ----------------------------------------------------------- //
class DefaultState implements State<DefaultService> {
#Override
public Consumer<Txn<DefaultService>> getFunction() {
return (txn) -> System.out.println("hurray now left is to do default at "+txn.getCurrent().getN());
}
#Override
public int getN() {
return 0;
}
}
class AState implements State<AService> {
private int n;
AState(int n) {
this.n = n;
}
#Override
public int getN() {
return n;
}
#Override
public Consumer<Txn<AService>> getFunction() {
return (txn) -> {
int n = txn.getCurrent().getN();
System.out.println(n);
txn.setCurrent(new AState(--n));
};
}
}

Basically Please program to the interfaces (4 changes listed below):
DefaultService already implements Service
State<AService> change to State<Service>
class AState implements State<Service>
program to the interfaces: class Txn<T extends Service> {
Corrected code below:
import java.util.function.Consumer;
public class GenericsTest {
AService service = new AService("Aservice");
new Txn<>(service).next();
new Txn<>(new DefaultState()).next();
}
}
// ----------------------------------------------------------- //
interface Service {
String getName();
<T extends Service> State<T> getState();// this is unclear how to use generics here
}
interface State<T extends Service> {
Consumer<Txn<T>> getFunction();
int getN();
}
// ----------------------------------------------------------- //
class Txn<T extends Service> {
private T service;
private State<T> current;
Txn(State<T> current) {
this.current = current;
}
Txn(T service) {
this.service = service;
this.current = this.service.getState();
}
int next() {
do {
current.getFunction().accept(this);
} while (current.getN()>0);
return current.getN();
}
public State<T> getCurrent() {
return current;
}
public void setCurrent(State<T> current) {
this.current = current;
}
}
// ----------------------------------------------------------- //
abstract class DefaultService implements Service {
private String name;
public DefaultService(String name) {
this.name = name;
}
public String getName(){
return this.name.toUpperCase();
}
}
class AService extends DefaultService {
public AService(String name) {
super(name);
}
#Override
public State<Service> getState() {
return new AState(6);
}
}
// ----------------------------------------------------------- //
class DefaultState implements State<DefaultService> {
#Override
public Consumer<Txn<DefaultService>> getFunction() {
return (txn) -> System.out.println("hurray now left is to do default at "+txn.getCurrent().getN());
}
#Override
public int getN() {
return 0;
}
}
class AState implements State<Service> {
private int n;
AState(int n) {
this.n = n;
}
#Override
public int getN() {
return n;
}
#Override
public Consumer<Txn<Service>> getFunction() {
return (txn) -> {
int n = txn.getCurrent().getN();
System.out.println(n);
txn.setCurrent(new AState(--n));
};
}
}

How to define protected, public and private in Generic JavaBean?

I am wondering how can I define protected, public and private properties in my class GenericBean, which will result in a JavaBean. So far I've declared a class, that will enable use to access the value of the Bean, however, I have no idea how I can handle different accesses for those properties. Any idea? Here is m y class:
abstract class GenericBean {
protected PropertyChangeSupport chg = new PropertyChangeSupport(this);
protected VetoableChangeSupport veto = new VetoableChangeSupport(this);
public void addPropertyChangeListener(PropertyChangeListener pcl) {
chg.addPropertyChangeListener(pcl);
}
public void removePropertyChangeListener(PropertyChangeListener pcl) {
chg.addPropertyChangeListener(pcl);
}
class BoundedProperty<T> implements PropertyChangeListener {
private String name;
private T value;
private Object chgHandlerObject;
private Method changeHandler;
public BoundedProperty(String name) {
this.name = name;
}
public T getValue() { return value; }
public void setValue(T newValue) {
T old = value;
value = newValue;
chg.firePropertyChange(name, old, value);
}
public void propertyChange(PropertyChangeEvent e) {
if (!e.getPropertyName().equals(name)) return;
if (changeHandler == null) return;
try {
changeHandler.invoke(chgHandlerObject);
} catch(Exception exc) {
exc.printStackTrace();
}
}
public void setChangeHandler(Object handl, String mname) {
try {
Method m = handl.getClass().getDeclaredMethod(mname);
chgHandlerObject = handl;
changeHandler = m;
chg.addPropertyChangeListener(this);
} catch(Exception exc) {
exc.printStackTrace();
return;
}
}
public void setChangeHandler(Object ohandler) {
try {
Method m = ohandler.getClass().getDeclaredMethod(name+"Change");
chgHandlerObject = ohandler;
changeHandler = m;
} catch(Exception exc) {
exc.printStackTrace();
return;
}
chg.addPropertyChangeListener(this);
}
public void removeChangeHandler() {
changeHandler = null;
chgHandlerObject = null;
chg.removePropertyChangeListener(this);
}
}
}
So that I can decide which methods are available for certain fields?

Using union and intersection method in a HashSet

I am having trouble using my custom set,MySet, using the basic function of union and intersecting. The program compiles without error but just returns an empty set.
Anybody see where the problem is?
public class MySet<E> extends TreeSet<E> {
Set<E> set;
public MySet(){
set = null;
}
public MySet(Set<E> set){
this.set = set;
}
public void union(Set<E> s){
set.addAll(s);
}
public void intersection(Set<E> s){
set.retainAll(s);
}
}
Main method
public class TestSet {
public static void main(String[] args) throws FileNotFoundException{
File f1 = new File("courseList1.txt");
File f2 = new File("courseList2.txt");
Scanner scan1 = new Scanner(f1);
Scanner scan2 = new Scanner(f2);
Set<Coarse> set1 = new HashSet<Coarse>();
Set<Coarse> set2 = new HashSet<Coarse>();
MySet<Coarse> mySet = new MySet<Coarse>(set1);
String designator;
int number;
while(scan1.hasNext()){
designator = scan1.next();
number = scan1.nextInt();
set1.add(new Coarse(designator, number));
}
while(scan2.hasNext()){
designator = scan2.next();
number = scan2.nextInt();
set2.add(new Coarse(designator, number));
}
mySet.union(set2);
mySet.intersection(set2);
}
}

It seems that you are trying to implement composition and at the same time extending the tree set, but that is not a good practice, you either use composition and implement the Set interface (backend with a TreeSet) or extends the tree set
Extending the TreeSet
class MySet<E> extends TreeSet<E> {
public void union(Set<E> s){
addAll(s);
}
public void intersection(Set<E> s){
retainAll(s);
}
}
using composition
class MySet<E> implements Set<E> {
private TreeSet<E> set;
public MySet(TreeSet<E> set) {
this.set = new TreeSet<>(set);
}
public void union(Set<E> s){
set.addAll(s);
}
public void intersection(Set<E> s){
set.retainAll(s);
}
#Override
public int size() {
return set.size();
}
#Override
public boolean isEmpty() {
return set.isEmpty();
}
#Override
public boolean contains(Object o) {
return set.contains(o);
}
#Override
public Iterator<E> iterator() {
return set.iterator();
}
#Override
public Object[] toArray() {
return set.toArray();
}
#Override
public <T> T[] toArray(T[] a) {
return set.toArray(a);
}
#Override
public boolean add(E e) {
return set.add(e);
}
#Override
public boolean remove(Object o) {
return set.remove(o);
}
#Override
public boolean containsAll(Collection<?> c) {
return set.containsAll(c);
}
#Override
public boolean addAll(Collection<? extends E> c) {
return set.addAll(c);
}
#Override
public boolean retainAll(Collection<?> c) {
return set.retainAll(c);
}
#Override
public boolean removeAll(Collection<?> c) {
return set.removeAll(c);
}
#Override
public void clear() {
set.clear();
}
#Override
public boolean equals(Object o) {
return set.equals(o);
}
#Override
public int hashCode() {
return set.hashCode();
}
}