Write a method with same logic but deals with different objects

It looks to me as if the root of your problem is the fact that Capital and Explore don't provide a uniform way for your updateOrInsert method to be able to identify your Explore and Capital objects.

I would consider generalising this and putting those methods into an interface which Explore and Capital are able to implement. For example, instead of getCode and getNumber, it could be generalised as getIdentifier instead:

interface IEntity {
    String getIdentifier();
    void setId(int id);
    int getId();
}

Each of the classes which you need to support within this pattern might look a bit like this, to ensure that you can work with them using the generalised interface instead:

class Capital implements IEntity {
    @Override public void setId(int id) { _id = id; }
    @Override public int getId() { return _id; }

    @Override public String getIdentifier() { return getCode(); }
    public string getCode() { return _code; }
}

class Explore implements IEntity {
    @Override public void setId(int id) { _id = id; }
    @Override public int getId() { return _id; }

    @Override public String getIdentifier() { return getNumber(); }
    public string getNumber() { return _number; }
}

This provides you with a uniform way for the updateOrInsert method to work with each of the individual objects.

The next issue is with the repositories.

Given how closely related your updateOrInsert method is to your repositories, I would recommend that you put this method into an abstract class that each of the repositories can extend, which also includes signatures for the find and save methods:

For example:

abstract class RepositoryBase<T extends IEntity> {
    public abstract List<T> findAllByIdentifierIn(List<String> list);
    public abstract List<T> saveAll(List<T> list);

    public List<T> updateOrInsert(List<T> list) {
        /* TODO: Implementation here */
    }
}

By putting a constraint using <T extends IEntity>, the updateOrInsert method will be able to use IEntity.setId, IEntity.getId and IEntity.getIdentifier

This approach allows repositories for Explore and Capital to extend BaseRepository then take advantage of the common base class logic for updateOrInsert:

class ExplorisRepository extends RepositoryBase<Explore> {
    @Override public List<Explore> findAllByIdentifierIn(List<String> list) {}
    @Override public void saveAll(List<Explore> list) {}
}

class CapitalRepository extends RepositoryBase<Capital> {
    @Override public List<Capital> findAllByIdentifierIn(List<String> list) {}
    @Override public void saveAll(List<Capital> list) {}
}

These Repository classes extend RepositoryBase by providing the real type of Capital or Explore. That means updateOrInsert no longer needs to be concerned with different types because the Repository class will pass that information up to the base. It always knows the exact type it's working with, and no need to perform any casting or type checking because <T> will be strongly typed as Explore or Capital or any of the other entities:

    // implementation of RepositoryBase<T>.updateOrInsert()
    public List<T> updateOrInsert(List<T> list){
        if (list == null || list.size() == 0) return list;

        List<String> identifiers = new ArrayList<>();
        list.forEach(item -> {identifiers.add(item.getIdentifier());});

        List<T> itemsFromDb = this.findAllByIdentifierIn(identifiers);

        Map<String, T> map = new HashMap<>();
        itemsFromDb.forEach(item -> {
            map.put(item.getIdentifier(), item);
        });

        list.forEach(item -> {
            T itemMap = map.get(item.getIdentifier());
            if (itemMap != null) {
                item.setId(itemMap.getId());
            }
        });

        return saveAll(list);
    }

This will work for any of the classes which implement IEntity -- it can work with the generalised IEntity.getIdentifier method instead of needing to worry about the specifics surrounding getNumber vs getCode (the concrete classes themselves take care of this issue).

There's no need to duplicate/copy-paste the logic for updateOrInsert because it's already inherited by each of the repositories.